It feels like a solid foundation for most typical AI workflows has crystalized during the past 6-8 months. Common practices, well-known tools, and approaches are settling into established patterns. Models at the frontier are improving in expected ways, and smaller models are becoming reliably usable.
Established practices
The following workflow patterns are most commonly understood by pros who build software and use agentic systems to manage servers daily:
- Choose a model and an agentic harness which are appropriate for the sort of work you need to complete in a project, and for the environment/requirements surrounding a project (the most common current model and agent choices are summarized in a separate section below).
- Use /goal or have your agent manually build a plan that can be executed and evolved over multiple long running sessions.
- Manage context length by following a concrete plan which produces artifacts that can be inspected and used across steps. Your plan and artifacts should enable a long running process to continue at any point in a new session. You should be able to chain sessions together by requesting a prompt to continue in another session, at any point along the way, and/or by having the LLM read a previous session (conversation) export file at any point. Your project artifacts - all the files contained in either a folder or a zip file which your agent can explore - should contain all the code, environment configuration information, and documentation which is required to begin work again from any checkpoint, with any other agentic system and/or LLM model. Also help manage context length and maximize GPU saturation by spawning sub-agents when possible, to help complete tasks more efficiently.
- Focus on building detailed engineering requirements, and comprehensive tests for any workflow in which the result can be concretely validated. When working with frontier models, allow the LLM to take on as much of this planning and testing as it's able to handle. Micro-managing baby steps for most typical projects is no longer required, and such interferance can unnecessarily limit a frontier model's agency, and the scope of its creative potential. Instead, always ensure that the model is explaining its choices and validating its work with tests. Have conversations with the model about the pros and cons of engineering choices which have been added to its plan. Be sure to clarify all potential upside/downside concerns which should be considered, about how potential future directions of a project may be affected by initial engineering choices.
- Orchestrate model usage so that larger, more expensive models build plans and complete complex reasoning steps which require significant world knowledge, delegate easier tasks to faster, cheaper, small models, and use bigger models to check the work of smaller models.
- After you've completed long horizon tasks, build skill packages to encapsulate all the in-context learning which was performed, to codify repeatable steps in any process which will be executed again in the future. Don't waste tokens going through that same trial and error exploration process again.
- Along with skills, build agent.md files and extensions for your agent, to establish workflow guidelines, to remember learned patterns, and to extend an agent's capability. Use existing skills, extensions, MCP servers and other tools, instructions, and prompts which have been proven successful by a community, to achieve common tasks.
Those guidelines are generally portable between all common LLMs and agentic harnesses, and the community has settled on a fairly short list of well known harnesses and LLMs.
Common agentic tools and established LLMs
Pi, Hermes, Codex, Claude Code, OpenCode, Cursor, Prime, Cline, and the new Deepseek harness seem to be the most popular agents.
OpenAI GPT-5.6 Sol/Terra/Luna, Anthropic Claude 5 Opus/Sonnet/Fable, Google Gemini 3.1 & 3.5 Pro/Flash, and xAI Grok 4.x are the most popular closed source frontier models (Gemini has fallen out of favor lately, and Grok seems to be coming back into favor since xAI purchased Cursor).
Kimi K3, Qwen 3.8 Max, DeepSeek V4 Pro, GLM 5.2, and Minimax 3 are the open source competitors at or near frontier capability.
Deepseek V4 Flash, Hy3, and Mimo 2.5 are the most capable self-hostable models which can be run on hardware with 128Gb VRAM, such as DGX Spark, Strix Halo, and Macintosh M3 machines. Those models are also the least expensive capable models to run on hosted APIs. Hardware to run those models locally starts around the $3000+ price point. 2 clustered DGX Spark machines ($8000+) is the ground floor for building a hardware system which can reasonably replace frontier model APIs (Deepseek V4 Flash and Minimax 3 are the most capable on that platform - near frontier level. I use Deepseek V4 Flash almost exclusively).
Qwen 3.8 27b, Qwen 3.6 (27b dense & 35a3 MOE) and Gemma 4 (31b dense and 26a4 MOE) are the most viable models which can be run on consumer GPUs with 16+Gb VRAM. RTX 3090 and other older/budget GPUs, along with Macintosh machines with 32+Gb shared VRAM, are popular for running those models. This class of hardware starts around $800+, and can be used to complete a wide range of real, useful coding and agentic work - but don't expect frontier class world knowledge or deep creative capability from those models. You'll need to manually manage workflows in smaller baby steps, provide more detailed engineering guidance for software development projects, and plan on many debug iterations, switch models more often to complete simpler tasks, and expect more errors along the way, when completing any task with those smaller models.
In the end, smaller models tend to be capable of completing a wide variety of common tasks with common tools, but they often need access to the Internet to research solutions, and they generally need a lot more human guidance, and require more iteration time, effort, and tokens to debug their work.
Deepseek V4 Flash
Deepseek V4 Flash has become the default model used by the open source community. I use Deepseek V4 Flash for most agentic work. The best priced reliable provider I've found is Cline-pass, which costs ~$6.80 per month on a yearly contract, but V4 Flash is also available on Openrouter, Ollama cloud, Deepseek.com, and many other providers who run it on their own hardware, so you don't have to worry that commercial cloud provider APIs will disappear. It's hard to hit a rate limit on Cline-pass with Deepseek V4 Flash, even if you use it all day every day. Deepseek V4 Flash is ridiculously fast, inexpensive, and capable at a near frontier level, for most common agentic tasks and development work.
I periodically use up any extra weekly available rate limit on Cline-pass with Kimi K3 and Qwen 3.8 Max, to get challenging creative projects planned, and to check progress & test completed work in projects where Deepseek V4 Flash has done the bulk of heavy lifting. I don't need those big models for most local work, but enjoy using extra tokens to work out complex long-term goals with the extra intelligence fire power.
OpenRouter continues to be my other primary LLM provider because it enables you to choose virtually any version of any common LLM, commercial or open source, without needing a dedicated subscription to any single provider - and also particularly because it's one of the easiest providers to set up in agentic systems and other AI tools (just paste in your OpenRouter API key, choose a model, and start working).
I also keep some money in a Deepseek account, because it's the fastest performing API I've seen for the Deepseek models, and it's good to keep an alternate provider ready to go (and the Deepseek API is also typically easy to set up in most agents and AI tools).
Bastiongpt.com has ended up being the HIPAA compliant LLM provider that I've used most in production environments, because it's easy to open an account and configure in applications, and because it offers a low monthly obligation ($45 minimum to maintain an account, and that fee gets applied directly to token usage), plus they provide access to multiple frontier LLMs, vision models, and other tools which are useful out of the box to medical clients.
Ollama cloud is another great provider of multiple open-source LLMs. They offer a zero data retention policy and they self-host models on their own managed servers, so an outage at downstream providers which affect other services such as OpenRouter, will not necessarily stop access to models in Ollama cloud. Their prices also seem to be very competitive, and they offer a very large variety of models.
Pi
Everyone has their favorite agent, but all agents fundamentally do the same thing - they give hands to your chosen LLM, to work with files and the operating system in your local environment.
Some people prefer using heavy agents such as Hermes and Codex, with all the bells and whistles built in (browser control, computer control, interactions via messaging systems, piles of built-in skills, etc.).
I prefer to use Pi coding agent exclusively for all my local work, because it's light weight, it sends the fewest possible tokens with each prompt submitted to the LLM, is easily extensible, runs comfortably pretty much anywhere (on local machines, on VPS over SSH, on Android phones in Termux, etc.)
You can simply ask Pi to change its own configuration (add provider models, for example), and/or to build skills, extensions, etc., and it will figure out how to implement any sort of addition to the system which you can imagine. There are plenty of existing community-built extensions for browser use, computer user, spawning sub-agents, and other common needs.
To be clear, 'local work' typically means installing any sort of infrastructure & project prerequisites, and performing IT tasks such as configuring OS settings, as well as writing any sort of code that requires many iterations that involve lots of interactions with a local operating system/environment.
ChatGPT
For most large development projects that don't require heavy local iterations, I still use my $20/month ChatGPT development workflow described at https://aibynick.com/thread/3 . That will remain my cornerstone workflow for building software, until OpenAI goes out of business or stops providing massive rate limits which are subsidized by hundreds of billions of dollars of investors' capital. GPT is one of the best frontier models for software development, it has massive world knowledge, and the ChatGPT environment includes tools which automatically spawn sub-agents as needed to manage context. Using the zip file workflow is the way I get basically unlimited work completed by a frontier level LLM, with rate limits that have never once stopped me from working in the middle of a project session, for outrageously large work loads, day after day, often for weeks in a row, all for $20 a month.
Flask, Web UIs, Python, SQLite
For most software development projects, I build with the Flask web framework, which most often includes plain HTML/CSS/JS and Bootstrap code in Jinja templates, for UI (plus Flask-SQLAlchemy for databases, Flask-Login for user sessions, Flask-WTF for forms, Flask-Migrate) and the rest of the Python and web UI ecosystems as the primary building blocks in applications.
I use SQLite as the production database for most in-house projects, and I think it's becoming the norm to use it more and more in the industry. For web scale, Postgres is the default, and MySQL is still popular. Microsoft shops tend to rely on MSSQL and the whole MS ecosystem (expect that a lot in government projects). It doesn't matter too much, since SQLAlchemy works with all those RDBMSs, and more.
Plain old HTML/CSS/JS/Bootstrap in a templating system such as Jinja, works best for UI
I have never needed to use React, Vue, Angular, Svelte or any of the other reactive UI frameworks, even for real-time systems. Those JS heavy front end frameworks seem to always reliably bloat and add complexity to large projects. Server based Flask rendering with Jinja templates typically seems to end up weighing 1/100th the project size, and LLMs always seem to have a dramatically better time working with Flask, than any other tooling I've ever used (I've spend many hundreds of hours over the past 4 years trying different software tools/ecosystems with LLMs). The Python/Flask ecosystem seems to be the most popular, versatile, effective and efficient for LLM based software development workflows, when it comes to building common types of useful operations software for businesses. Python can connect to virtually any existing infrastructure on most commonly used OS/server platforms, and it's accepted in virtually every IT environment. Flask clients apps run instantly in virtually any common browser, and can be updated instantly, without users needing to install any software locally.
Go is likely the next best ecosystem for any LLM based software development which requires deep performance optimization, but LLMs should now be able to work optimally with any other well known tools in any popular language ecosystem (C#, Rust, JavaScript, etc.).
Self hosted local models
The most popular model for serious local self-hosted inference is Deepseek V4 Flash. That model has become the cornerstone for the open source community. It runs on a single DGX Spark (I use the Asus GX10 version) in the DS4 engine, at 2-bit quantization (this is actually a mixed 2-8 bit quant)) which is usefully capable, and it runs at the very reliable 4-bit quantization on 2 clustered DGX Spark machines. Those models run between 12-26 tokens per second on DGX Spark, which is usable for most tasks. It's great to be able to switch from using Deepseek V4 Flash on a hosted API, running at 200 tokens per second, for a few dollars per month, to a locally hosted version for privacy and compliance needs, all using the exact same familiar model.
I use Qwen 3.6 35a3 (the MOE version) most often for tasks that I know it can handle well (most typical CRUD and basic software development tasks and basic structured data management tasks, database interactions, etc.), when I want faster performance. It runs at least 50+ tokens per second at full precision on the 128Gb platforms, and 20+ tokens at 4 bit quantization on even the least capable machines with 16Gb+ VRAM GPUs. Gemma 4 26a4 gets tossed in the mix for its vision capabilities, and for example, to help with tasks in which a 4 bit Qwen 3.6 quant might get stuck in a loop.
Honesty, though, I typically just rely on running Deepseek V4 Flash on the the DGX Spark machines for most locally hosted tasks. And my locally hosted work is typically limited to working with PHI data on projects which require HIPAA compliance.
For everything else, I tend to start with ChatGPT and the zip file routine for building commercial Flask projects, and Deepseek V4 Flash on the Cline-pass API for installing and building software that interacts with any local environment. Fable, GPT Sol, Kimi K3, and Qwen 3.8 are great at achieving amazing software development, engineering, math, research and other STEM goals, which most humans are not capable of - I've completed a few projects which have made use of that level of capability, and what was accomplished has been astounding.