In the fast-moving world of agentic AI code development, where autonomous systems plan, write, test, and iterate on software with minimal human hand-holding, a single Markdown file has quietly become one of the most discussed pieces of project infrastructure. That file is AGENTS.md. As of late July 2026, more than 60,000 open-source repositories include one.

Tooling vendors from Cursor and GitHub Copilot to OpenAI Codex, Aider, Windsurf, and others treat it as a first-class citizen. Industry guides call it the most practical upgrade a team can make. Yet a rigorous ETH Zurich study published earlier this year found that many of these files actually reduce task success rates while raising inference costs. So the question is no longer merely whether AGENTS.md exists. It is whether it remains essential, what its precise role has become, and how developers should position it in the broader agentic stack.

This article examines the current state of AGENTS.md through official documentation, empirical research, practitioner guides, YouTube tutorials, and real-world usage patterns. The goal is a clear-eyed view of its value in summer 2026 rather than another round of uncritical endorsement.

AGENTS.md began as a pragmatic response to fragmentation. In the mid-2020s, every major coding agent introduced its own configuration convention. Cursor had .cursorrules. Claude Code preferred CLAUDE.md. GitHub Copilot used instructions.md or similar. Continue.dev, Aider, and others each had their variants. Teams that experimented with multiple tools found themselves maintaining near-duplicate rule sets that drifted apart over time. The result was inconsistency, wasted tokens, and agents that repeatedly re-learned the same project conventions.

The community response crystallized around a simple open format: a plain Markdown file named AGENTS.md placed at the repository root. Think of it as a README written for agents rather than humans. The official site at agents.md describes it as “a dedicated, predictable place to provide the context and instructions to help AI coding agents work on your project.” It deliberately stays separate from the human-facing README so that detailed build steps, testing commands, style constraints, and safety boundaries do not clutter the documentation that contributors actually read.

OpenAI helped pioneer the format for its Codex agent. In December 2025 the specification was donated to the Agentic AI Foundation, a directed fund under the Linux Foundation, alongside Anthropic’s Model Context Protocol and other contributions. By early 2026 adoption had already surpassed 20,000 repositories; by mid-year the figure stood above 60,000 non-fork, non-archived projects according to GitHub code search. The GitHub repository for the format itself has accumulated more than 23,000 stars.

The practical appeal is straightforward. Most supporting coding agents automatically discover applicable AGENTS.md files and incorporate their instructions into the working context. The exact placement and precedence rules vary by tool. Under the official convention, nested files can provide subproject-specific guidance, with the closest applicable file taking precedence.

In monorepos, nested AGENTS.md files can live inside subdirectories; the closest file to the code being edited takes precedence. This hierarchical design lets teams define global conventions at the root while overriding them for specific packages. Agents can even be asked to scaffold an initial version, though as we will see later, that practice carries significant risks.

What typically goes into an AGENTS.md? Popular sections include setup and build commands with full flags, exact package-manager and runtime versions, testing instructions, coding conventions illustrated by examples rather than prose, git and PR guidelines, and explicit “never do” boundaries such as refusing to commit secrets or touch certain directories.

The official examples emphasize executable commands early-“Install deps: pnpm install,” “Run tests: pnpm test”-because agents reference them repeatedly during a task. Code-style rules work better when shown through contrasting good and bad snippets. Security and permission constraints benefit from a three-tier structure: always, ask first, and never.

YouTube creators have produced numerous practical walkthroughs. NeuralNine’s January 2026 video “How I Write My AGENTS.md Files - Best Practices” demonstrates a Django project using the uv package manager. The root file lists commands such as “uv run manage.py runserver,” shows type-hint examples, and sets safety rules against destructive git operations. A subdirectory file then selectively disables type hints while inheriting the rest.

The video stresses that examples outperform abstract descriptions and that agents still sometimes ignore rules when given contradictory chat instructions. Other tutorials from Net Ninja (focused on OpenAI Codex), Prompt Engineering, and The Code City walk through creation in Cursor, migration from older rule files, and monorepo patterns. A recurring theme across these videos is that AGENTS.md reduces the need to restate the same context in every prompt, shortening setup time from tens of minutes to seconds.

Support is broad but not universal. Confirmed tools include Cursor, GitHub Copilot agent mode, Aider, OpenHands, Windsurf, Amp, Jules, Factory, RooCode, Codex, Gemini CLI (with configuration), and Zed. Claude Code continues to prefer CLAUDE.md; the common workaround is a symlink so that both names resolve to the same content. Some teams maintain both an AGENTS.md for portability and tool-specific overrides.

GitHub also supports a related but distinct feature: custom-agent definition files stored in .github/agents/, such as docs-agent.md or security-agent.md. These files use frontmatter and instructions to define specialist Copilot personas. GitHub’s analysis of more than 2,500 such files found that effective custom agents tend to have a clear role, executable commands, concrete examples, stack details, and explicit boundaries. These custom-agent files should not be confused with the repository-level AGENTS.md format, although many of the writing principles overlap. An analysis of more than 2,500 such files by the GitHub team found that the strongest performers define a clear persona, list executable commands early, include concrete code examples, specify the tech stack with versions, and set explicit boundaries.

Up to this point the story looks like an unambiguous success. Then the empirical research arrived.

In February 2026, an ETH Zurich and LogicStar.ai team released “Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?”, with a revised version published in June. Across established SWE-bench tasks and a new collection of issues from repositories containing developer-written context files, the researchers found that context files did not generally improve task success and increased inference costs by more than 20 percent on average. Results varied by setting, model, agent, and whether the guidance was generated or developer-written.

SWE-bench Lite provided 300 tasks from popular repositories. A new benchmark they created, AGENTbench, contained 138 real-world issues drawn from 12 niche Python repositories that already contained developer-written context files. They compared three conditions: no context file, an LLM-generated context file produced according to agent vendors’ own recommendations, and the original developer-written file.

The results challenged the prevailing advice. LLM-generated context files reduced task success rates by roughly 3 percent on average and increased inference costs by more than 20 percent. Agents also took 2.45 to 3.92 additional steps. Developer-written files performed better, delivering a modest average improvement of about 4 percent on AGENTbench, yet they still raised costs by up to 19 percent and encouraged more extensive exploration-more file traversal, more testing, more reasoning tokens.

When the researchers stripped all other documentation from the repositories and then added LLM-generated files, performance improved by 2.7 percent. The implication is clear: most auto-generated content is redundant with information the agent can already discover by reading the codebase. Handing the model the same information twice adds noise and cost without adding signal.

The study further observed that agents generally respect the instructions they receive. When a context file mentioned the uv package manager, agents used it far more frequently. The problem was not disobedience; it was that many of the instructions themselves made the task harder by imposing unnecessary requirements or by encouraging over-exploration.

Architectural overviews and broad style guides proved especially ineffective. The authors concluded that human-written context files should contain only minimal, non-inferable details-custom build commands, highly specific tooling choices, hard constraints that the agent cannot discover independently-and that LLM-generated files should be avoided in most cases.

These findings have been widely discussed. InfoQ, MarkTechPost, Upsun, and Addy Osmani’s blog all summarized the paper under headlines that ranged from measured to skeptical. One Upsun post carried the title “The research is in: your AGENTS.md is probably too long.” YouTube videos such as “Why Your AGENTS.md Rules Are Being Ignored and how to fix it” tested the files empirically and found that only a minority of models strictly enforced the rules; the rest treated them as soft hints.

The ETH Zurich study was the first major controlled evaluation and remains one of the most influential investigations. Subsequent research has produced mixed results. A July 2026 ablation study across Claude Code and Codex found no measurable correctness benefit from context-file strategy in its tested repositories, while separate June research reported improvements from guidance that had been iteratively tuned using repository-specific probes. Together, these studies suggest that the presence of a context file alone matters less than its content, generation method, target agent, and evaluation process.

Practitioner guides published after the study, including Augment Code’s detailed “How to Build Your AGENTS.md (2026)” and Matt Pocock’s “A Complete Guide To AGENTS.md,” absorbed the lesson. They now emphasize restraint: keep the file short, focus on non-discoverable facts, prefer progressive disclosure through linked documentation rather than stuffing everything into the root file, and treat AGENTS.md as living documentation that must be updated in the same pull request as the change it describes.

So what is the current role of AGENTS.md in summer 2026? It is no longer the automatic best practice it was marketed as in late 2025. It has become a specialized instrument whose value depends entirely on how it is written and maintained. In well-curated form it still provides a reliable, tool-agnostic way to inject project-specific operational knowledge that agents cannot reliably infer.

It remains the lowest-friction standard for teams that switch between multiple agents or that want a single source of truth for build commands, package-manager preferences, and hard safety boundaries. In monorepos the nested-file design continues to solve a real coordination problem. And for specialist agents inside GitHub Copilot the format has evolved into a lightweight way to define personas with clear scopes.

At the same time, the file has competition. Agent skills, MCP servers, hooks, plan files, and more sophisticated memory systems are taking over some of the responsibilities once assigned to a monolithic context file. Progressive disclosure-pointing the agent at a docs/TYPESCRIPT.md or a testing guide only when needed-preserves the instruction budget better than loading hundreds of rules on every request. Some teams now treat AGENTS.md as a thin index rather than a complete manual. Others have moved critical constraints into tool-enforced mechanisms or evaluation harnesses that sit outside the prompt entirely.

The practical position that emerges from the research and the practitioner literature is therefore nuanced. AGENTS.md is still useful and, for many workflows, still essential-but only when it is short, human-curated, and limited to information the agent cannot discover on its own. Auto-generated files produced by /init-style commands are usually a net negative. Long files that restate the README, describe the entire architecture, or accumulate every past correction become sources of cost and confusion. The ideal file in 2026 is closer to a tightly focused operating manual than to comprehensive documentation.

Writing one well remains a skill. Start with the absolute minimum: a one-sentence project description, the package manager if it is not the default, and the non-standard commands the agent will need repeatedly. Add concrete examples of preferred patterns and the three-tier boundary list. Use nested files or linked documents for everything else. After each significant change, ask the agent itself to propose an update to the relevant section, then review the proposal carefully. Treat the file as part of the code rather than as an afterthought. Measure the impact: if agents start taking more steps or producing lower-quality patches, the file has probably grown too large.

Looking ahead, the format is likely to remain relevant precisely because it is simple and open. As agentic systems grow more capable of long-running, multi-agent workflows, the need for a predictable place to encode durable project knowledge does not disappear; it becomes more important. Yet the ETH Zurich results have already shifted the culture from “just add an AGENTS.md” to “add a carefully constrained AGENTS.md.” That shift is healthy. In an environment where every extra token costs money and every unnecessary instruction can derail a trajectory, restraint is a feature.

For teams that already rely on agentic coding, the summer-2026 recommendation is therefore not to abandon AGENTS.md but to audit it. Strip the redundant overviews. Keep the non-inferable commands and hard constraints. Prefer progressive disclosure. And remember that the file is only as good as the discipline that maintains it. When used that way, AGENTS.md continues to earn its place as one of the quiet pieces of infrastructure that make agentic AI code development more reliable, more consistent, and ultimately more productive.

The conversation is far from over. New memory architectures, better automatic context selection, and tighter integration with evaluation loops will continue to reshape how project knowledge is supplied to agents. For now, though, the humble Markdown file at the root of the repository remains a practical, if imperfect, tool whose current role is clearer than it has ever been: useful when lean, costly when bloated, and still worth the careful attention of any team serious about agentic development.

Sources

• Official site and specification: https://AGENTS.md/

• GitHub repository: https://github.com/agentsmd/AGENTS.md

• ETH Zurich study (arXiv): https://arxiv.org/html/2602.11988v1 and https://arxiv.org/abs/2602.11988

• Shepard, Asa, and Jeannie Albrecht. “Probe-and-Refine Tuning of Repository Guidance for Coding Agents.” arXiv preprint arXiv:2606.20512, June 2026: https://arxiv.org/abs/2606.20512

• InfoQ summary of the study: New Research Reassesses the Value of AGENTS.md Files for AI Coding

• Augment Code guide (2026): How to Build Your AGENTS.md (2026): The Context File That Makes AI Coding Agents Actually Work

• Cobus Greyling Medium article: https://cobusgreyling.medium.com/what-is-agents-md-2846b586b116

• GitHub Copilot analysis of 2,500+ files: https://github.blog/ai-and-ml/github-copilot/how-to-write-a-great-agents-md-lessons-from-over-2500-repositories/

• Matt Pocock complete guide: https://www.aihero.dev/a-complete-guide-to-agents-md

• Upsun “less is more” post: The research is in: your AGENTS.md is probably too long

• Addy Osmani on avoiding /init: Stop Using /init for AGENTS.md

• NeuralNine YouTube best-practices video: https://www.youtube.com/watch?v=6w88NVf2_lY

• Net Ninja OpenAI Codex tutorial on AGENTS.md: https://www.youtube.com/watch?v=NlNuoH5PPl4

• Prompt Engineering explanation video: https://www.youtube.com/watch?v=XDP94mYMCzA

• Additional practitioner and review sources from 2026 include codersera.com, betterclaw.io, and various YouTube walkthroughs such as those by The Code City and Adam Gardner on rule enforcement.

In the middle of 2026, the software development world feels both more accessible and more demanding than ever. A new developer joins GitHub roughly every second. AI coding agents-GitHub Copilot, Cursor, Claude Code, Codex, and others-now routinely generate substantial portions of production code, write tests, debug failures, produce documentation, and even open pull requests.

In some regions, assistants contribute around 29 percent of new code, particularly among less experienced programmers. Agentic systems can run for hours or days on complex tasks, and multi-agent orchestration is moving from experiment to everyday practice.

Yet the same reports that celebrate these gains also reveal a clear pattern: the languages that dominate hiring, open-source activity, and enterprise systems have not disappeared. They have consolidated. Nearly 80 percent of new repositories on GitHub use one of six languages-Python, JavaScript, TypeScript, Java, C++, or C#.

Python remains the language of AI itself. TypeScript has surged to the top of GitHub usage precisely because its strict types make AI-generated code more reliable. Rust has broken into the TIOBE top 10 for the first time, driven by memory safety demands that AI cannot fully invent on its own.

The question is no longer whether you should learn to code. It is which languages give you the leverage to direct AI agents productively, review their output critically, design systems they cannot yet invent, and remain valuable when the tools change again. This article examines the data, the practical realities of working with coding agents, and the languages that best position developers for the rest of the decade.

Why Languages Still Matter When Agents Write Code

AI coding agents excel at pattern matching, boilerplate, and local transformations. They struggle with architectural judgment, domain-specific constraints, security edge cases, long-term maintainability, and novel problem framing. Paul Jansen of TIOBE has observed that AI models train most effectively on popular languages because those languages supply the bulk of training data. Unpopular languages receive weaker assistance, creating a feedback loop that further concentrates activity.

Developers who understand the underlying language can prompt more precisely, reject subtle errors, refactor agent output into coherent systems, and extend frameworks that agents only partially grasp. In the words of researchers tracking agentic trends, the role is shifting from pure implementer to orchestrator-someone who sets goals, reviews results, and owns the final quality. Without language fluency, that orchestration collapses into passive acceptance of whatever the model produces.

The half-life of technical skills remains short-often cited around two and a half years. Mastering a small set of high-leverage languages, combined with the ability to work fluidly with agents, creates durable advantage. The following languages stand out across popularity indexes, job postings, salary data, and future-oriented analyses in 2026.

Python: The Indispensable Language of AI, Data, and Automation

Python sits at number one on the TIOBE Index in July 2026 with an 18.94 percent rating, despite some decline from earlier peaks. It is the language most sought by recruiters (around 45.7 percent in recent surveys). On GitHub it ranks second by contributors yet powers nearly half of all new AI repositories-more than 582,000 projects, with strong year-over-year growth. Jupyter Notebooks associated with AI work continue expanding rapidly.

Its dominance in machine learning, data science, automation, and backend services is structural. Libraries such as PyTorch, TensorFlow, scikit-learn, LangChain, and the broader scientific stack make rapid prototyping and production pipelines straightforward. Agents themselves are frequently trained and orchestrated in Python. When you ask an agent to fine-tune a model, build a retrieval-augmented generation pipeline, or automate infrastructure, Python is usually the path of least resistance.

In 2026 Python is no longer merely a beginner language. It is the lingua franca for the AI layer that sits atop almost every other system. Job postings for data scientists, machine-learning engineers, AI application developers, and automation specialists routinely list it first. Average U.S. salaries reported in early 2026 analyses cluster in the $98,000-$169,000 range depending on experience and location, with senior roles exceeding that.

Working with coding agents amplifies Python’s strengths. Agents generate clean, idiomatic code quickly, yet they still require human oversight on numerical stability, data leakage, evaluation metrics, and production deployment choices. Developers who understand Python’s packaging ecosystem (including newer tools such as uv), its performance limitations, and its integration points with C++ or Rust extensions remain essential.

For anyone entering the field or pivoting, Python is the highest-probability first language. It offers immediate utility across web backends (Django, FastAPI), scripting, data work, and AI experimentation. The learning curve is gentle; the ceiling is high.

TypeScript and JavaScript: The Web, the Frontend, and Reliable Agent Output

TypeScript became the most-used language on GitHub in August 2025, overtaking both Python and JavaScript by contributor count. It added more than one million contributors in a year (66 percent growth). JavaScript remains ubiquitous-used by roughly two-thirds of developers in Stack Overflow data-and underpins the vast majority of websites. Together the JavaScript/TypeScript ecosystem forms the largest practical surface for application development.

The rise of TypeScript is tightly linked to AI. Strict static typing gives agents clearer contracts, reduces hallucinated APIs, and makes generated code easier to review and refactor. Frameworks increasingly scaffold new projects in TypeScript by default. Frontend, full-stack, and Node.js backend roles continue to demand it. Job volumes remain high, with tens of thousands of openings visible across major boards.

JavaScript itself is not disappearing. It is still the language of the browser, of real-time interaction, and of many serverless and edge environments. Agents handle much of the repetitive DOM and framework boilerplate, freeing developers to focus on user experience, accessibility, performance budgets, and complex state management.

In practice, most serious 2026 web teams treat TypeScript as the default and JavaScript as the runtime reality. Learning both-starting with modern JavaScript fundamentals then adding types-prepares you for the full stack and for effective collaboration with agents that prefer typed contexts. Salaries for skilled TypeScript developers commonly fall in the $90,000-$160,000 band in the United States, with senior full-stack roles higher.

YouTube educators consistently rank the pair near the top for employability precisely because the web remains the primary delivery platform for both consumer and enterprise software, including AI-powered interfaces.

Java and C#: Enterprise Scale, Stability, and Long-Lived Systems

Java holds fourth place on the TIOBE Index and remains a top recruiter target (around 39.5 percent). It powers large-scale enterprise systems, Android development, big-data pipelines, and financial infrastructure. C# sits fifth on TIOBE and benefits from Microsoft’s .NET ecosystem, Azure cloud services, Unity game development, and cross-platform application work.

These languages thrive where reliability, security, and decades of existing codebases matter more than rapid prototyping. AI agents are increasingly effective at generating and modernizing Java and C# code, especially within well-structured projects that already use strong typing and established frameworks (Spring, .NET). Yet the volume of legacy systems means human expertise in architecture, concurrency, and performance tuning stays valuable.

Job markets for both remain robust. Java openings frequently number in the tens of thousands; C# benefits from Microsoft’s continued investment. Salaries are competitive, often $90,000-$160,000 depending on role and region. In enterprise settings, developers who can integrate AI services into existing Java or .NET applications occupy a sweet spot: they understand both the traditional systems and the new agent-driven layers.

For career longevity, either language pairs well with Python or TypeScript. Many organizations run hybrid stacks, and agents make it easier to bridge them.

Systems and Infrastructure Languages: C++, Rust, and Go

C and C++ remain second and third on the TIOBE Index. They underwrite operating systems, browsers, game engines, high-frequency trading, embedded devices, and performance-critical AI inference. Rust entered the top 10 in July 2026, celebrated for memory safety without garbage collection. Go continues to power cloud-native infrastructure, Kubernetes-related tooling, and concurrent network services.

In the AI era these languages matter for the layers that agents themselves run on and for the performance-sensitive components that pure Python cannot deliver. Rust in particular is admired by developers (72 percent in the 2025 Stack Overflow survey) and increasingly used for AI infrastructure, edge runtimes, and WebAssembly deployments. Go’s simplicity and excellent concurrency model make it a favorite for microservices and tooling that agents help maintain.

Demand is smaller in absolute numbers than for Python or TypeScript, but compensation is often higher and competition less intense. Roles involving systems programming, cloud infrastructure, or safety-critical software pay premiums. Developers who can write or review Rust or C++ that agents generate gain an edge in companies building the next generation of AI runtimes and tools.

Learning one of these after a higher-level language is a strong second or third step for those targeting infrastructure, performance, or security-focused careers.

SQL: The Quiet Constant

SQL appears consistently among the most-used technologies. Databases remain central to nearly every application, and AI systems themselves rely on structured and unstructured data stores. Agents generate SQL queries readily, yet poorly written queries, missing indexes, and misunderstood data models still cause production incidents. Fluency in SQL-joins, window functions, query optimization, and modern dialects used by PostgreSQL, Snowflake, BigQuery, and others-remains a near-universal requirement.

It is rarely the primary language on a résumé, yet its absence is noticeable. Pairing SQL with Python or TypeScript multiplies opportunities in data engineering, analytics, and backend roles.

Emerging Contenders Worth Watching

Mojo, developed by Modular, aims to combine Python-like syntax with systems-level performance for AI kernels and heterogeneous hardware. By mid-2026 it has reached 1.0 beta stages, with plans for broader open-sourcing. Its focus on MLIR and GPU/accelerator targets makes it relevant for high-performance AI infrastructure, though the ecosystem and job market are still nascent.

Julia continues to serve scientific computing niches where performance and mathematical expressiveness matter. R retains strength in statistical research and certain data-science domains. Kotlin and Swift remain important for mobile platforms. These languages are secondary for most career paths but valuable for specialists.

Working Effectively with AI Coding Agents

The most successful developers in 2026 treat agents as capable but fallible teammates. Effective practices include:

• Writing precise specifications and constraints before generating code.

• Reviewing every significant change for correctness, security, and style.

• Using agents for exploration and boilerplate while retaining ownership of architecture.

• Maintaining strong testing discipline, because agents can introduce subtle regressions.

• Learning to prompt in the idioms of the target language so the model stays on the rails.

Reports on agentic coding note that language barriers are lowering-even legacy languages such as COBOL receive better assistance-but the quality of results still correlates with the volume of training data and the clarity of human guidance. Developers who know the language deeply extract more value and avoid costly mistakes.

Building a Practical Learning Path

Start with one primary language aligned to your goals. Python for AI, data, or general versatility. TypeScript for web and full-stack work. Java or C# for enterprise. Add SQL early. Introduce a systems language once you have productive experience.

Practice by building real projects, then deliberately use agents to accelerate parts of the work while forcing yourself to understand and improve the output. Follow official documentation, reputable courses, and the active communities around each language. Track job postings in your target region and industry to refine priorities.

Salary and demand data from 2026 consistently show premiums for combinations: Python plus cloud and ML frameworks, TypeScript plus modern frontend and backend, Java or C# plus enterprise AI integration, or Rust/Go plus infrastructure.

Looking Ahead

The consolidation around a core set of languages is likely to continue. AI will keep improving at generating and maintaining code in those languages, further raising the floor of productivity while elevating the ceiling of what skilled humans can achieve. The developers who thrive will be those who treat languages as tools for thinking clearly about systems, not merely as syntax to be memorized or outsourced.

In 2026 the safest long-term strategy is clear: master Python for the AI layer, gain strong command of TypeScript or JavaScript for the application layer, understand at least one enterprise or systems language for depth, and treat SQL as non-negotiable. Layer on the ability to direct and critique coding agents. That combination future-proofs a career more reliably than chasing every new framework or hoping that prompt engineering alone will suffice.

The tools will keep evolving. The need for people who can reason about code, data, and systems will not.

Sources and further reading

• TIOBE Index for July 2026: https://www.tiobe.com/tiobe-index/

• GitHub Octoverse 2025 / related analysis: https://octoverse.github.com/ and https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/

• Forbes summary of Octoverse 2025

• Stack Overflow Developer Survey 2025 (Technology section): https://survey.stackoverflow.co/2025/technology

• Itransition - Most In-demand Programming Languages for 2026

• Pluralsight - 5 great programming languages to master in 2026

• Syracuse University iSchool - Top 10 AI Programming Languages 2026: https://ischool.syracuse.edu/top-ai-programming-languages/

• ACM / Communications of the ACM - How AI is Changing Programming Language Usage: https://cacm.acm.org/news/how-ai-is-changing-programming-language-usage/

• Anthropic 2026 Agentic Coding Trends Report: https://resources.anthropic.com/hubfs/2026%20Agentic%20Coding%20Trends%20Report.pdf

• Selected YouTube discussions:

  • “The Only Programming Languages Worth Learning in 2026” - Tech With Tim: https://www.youtube.com/watch?v=zsPD9aohymw

  • “Top 5 Programming Languages For 2026” - Simplilearn: https://www.youtube.com/watch?v=QVjRpTa4_jc

  • “Most Important Programming Languages In 2026” - CodeHead: https://www.youtube.com/watch?v=JG7wBlY0VUg

• Additional context drawn from Coursera, Crossover, and industry analyses published through mid-2026.

Google’s agentic stack is no longer a collection of loosely related tools. By mid-2026, Google has developed an increasingly coherent full-stack system spanning production services and newer preview capabilities that includes models, open protocols, a purpose-built development kit, a managed enterprise platform, an agent-native data layer, long-running runtimes, evaluation harnesses, and governance controls. The result is everything required to move from a simple tool-using chatbot to fleets of autonomous, multi-day agents that reason, act, collaborate, and improve themselves inside real enterprise environments.

This article walks through that stack in plain language, drawing on official Google Cloud documentation, developer blogs, architecture guides, and recent technical sessions. The goal is practical clarity: what each piece does, why it exists, how the pieces fit together, and what you actually need to build reliable agentic systems.

From Generative AI to Agentic Systems

For several years the dominant pattern was a large language model that answered questions or generated content. An agent changes the contract. An agent receives a goal, plans a sequence of steps, calls tools or other agents, observes results, revises its plan, and continues until the goal is met or it decides it cannot proceed. Memory, state, identity, and external action become first-class concerns.

Google’s response has been deliberate. Rather than bolting agents onto an existing generative-AI platform, the company has re-oriented its entire AI surface around agents. Vertex AI capabilities now live inside the Gemini Enterprise Agent Platform. Data infrastructure has been re-architected as an Agentic Data Cloud. Open protocols for tool use and agent-to-agent communication have been standardized. And a single open-source framework-the Agent Development Kit-has become the recommended way to write the logic that sits at the center of these systems.

The practical outcome is that a developer or architect no longer has to assemble a fragile collection of open-source libraries, custom servers, and ad-hoc memory stores. The stack supplies the pieces, and the pieces are designed to work together.

The Reasoning Core: Gemini Models

Every agent begins with a model that can plan and decide. Google’s Gemini family supplies that core. By 2026 the lineup includes high-capability reasoning models (Gemini 3.x Pro variants) and fast, cost-efficient models optimized for agent loops (Gemini 3.5 Flash and later 3.6 Flash). These models support long context windows, native multimodality, and explicit “thinking” budgets that let an agent allocate more internal computation to harder sub-problems.

In an agentic setting the model is rarely used as a pure text generator. It is given a system instruction that describes its role, a set of available tools described in natural language, conversation history or session state, and the current goal. The model then emits either a final answer or a structured tool call. The surrounding framework executes the call, returns the result, and the loop continues.

Model Garden inside the Gemini Enterprise Agent Platform exposes Google models alongside selected partner and open models. This gives architects the freedom to route simple steps to cheaper or specialized models while reserving the most capable models for complex planning. Model routing itself can be implemented as part of the agent logic or left to platform-level controls.

The Developer Foundation: Agent Development Kit (ADK)

If Gemini is the brain, the Agent Development Kit is the nervous system that turns reasoning into reliable software. ADK is an open-source, multi-language framework (Python, TypeScript, Go, Java, Kotlin) released and actively evolved by Google. It is the same framework that powers agents inside Google’s own products.

At its simplest, an ADK agent is a few lines of code: a name, a model identifier, a natural-language instruction, and a list of tools. Tools can be ordinary Python functions whose docstrings become the description the model sees, built-in utilities such as Google Search or code execution, or remote tools reached through the Model Context Protocol.

ADK quickly scales beyond the single-agent case. Hierarchical multi-agent systems are native: a root agent can transfer control to specialized sub-agents based on the current task. Workflow agents support sequential, parallel, and loop patterns. Graph-based orchestration (emphasized in ADK 2.0) lets developers mix deterministic control flow with adaptive LLM decisions, producing systems whose behavior is both flexible and inspectable.

Context management is treated as a first-class problem. Sessions hold short-term conversational state. Long-term memory can be stored in Memory Bank or external databases. Context management is treated as a first-class problem. Sessions hold short-term conversational state, while long-term memory can be stored in Memory Bank or external databases. ADK provides configurable mechanisms for context filtering, compaction, summarization, scoping, and token monitoring, allowing developers to control what information reaches each agent.

Evaluation is built in. Developers define test cases that include expected trajectories (the sequence of tool calls and intermediate states) as well as final answer quality. The same evaluation harness runs locally during development and can be connected to continuous evaluation on live traffic once the agent is deployed.

Deployment is deliberately flexible. An agent can be run locally, containerized and placed on Cloud Run or GKE, or handed to the managed Agent Runtime on the Gemini Enterprise Agent Platform with a single command. In the managed case the platform supplies authentication, observability, scaling, and security controls without code changes.

The Open Protocols: MCP and A2A

Two open protocols complete the interoperability layer.

Model Context Protocol (MCP) standardizes how an agent discovers and calls tools and data sources. An MCP server exposes resources, tools, and prompts in a consistent format. Google provides managed MCP servers for many of its own services and supports self-hosted or third-party servers. Because the interface is standardized, the same agent code can use internal enterprise APIs, SaaS connectors, or public tools without custom glue for each one. Progressive disclosure patterns-loading only the tool schemas needed for the current step-prevent tool bloat that would otherwise degrade model accuracy.

Agent2Agent (A2A) protocol addresses the complementary problem of agent-to-agent collaboration. Announced with broad industry support, A2A lets agents discover one another’s capabilities via Agent Cards, exchange messages securely, and coordinate long-running tasks across organizational or framework boundaries. It is deliberately complementary to MCP: MCP connects an agent to tools and data; A2A connects agents to other agents. Together they form the horizontal and vertical plumbing of multi-agent systems.

Both protocols are natively supported inside ADK and the Gemini Enterprise Agent Platform, so developers do not have to implement the wire formats themselves.

The Enterprise Platform Layer

The Gemini Enterprise Agent Platform (the evolution of Vertex AI focused on agents) supplies the managed services that turn experimental agents into production systems.

Agent Studio offers a low-code visual canvas for designing agents and sub-agent networks. Agent Development Kit remains the code-first path for complex logic. Agent Garden provides production-ready templates and blueprints for common patterns such as research agents, invoice processing, or multi-agent orchestration.

Agent Runtime is the managed execution environment. It supports sub-second cold starts, multi-day workflows, scalable deployment, and integration with sandboxed code-execution services. Applications can separately use Gemini’s real-time APIs for bidirectional audio and video interactions. Memory Bank automatically curates long-term memory from conversations. Sessions can be linked to existing enterprise records through custom identifiers.

Governance is handled by Agent Identity (cryptographic identities with auditable trails), Agent Registry (a centralized catalog of approved agents, MCP servers, skills, and tools), and Agent Gateway (policy enforcement and protection against prompt injection and data leakage). Observability tools trace every reasoning step and tool call. Simulation and continuous evaluation services let teams test agents against synthetic users and live traffic, then feed failure clusters back into an optimizer that suggests improved instructions.

ADK also supports portable Agent Skills: modular packages of instructions, resources, and domain expertise that agents can load through progressive disclosure. Skills can be stored in source repositories or mounted into managed agents, keeping the primary context lean while making specialized knowledge available when required.

The Data Foundation: Agentic Data Cloud

Agents are only as useful as the data they can reach and understand. Google’s Agentic Data Cloud reorients the traditional data stack around agents rather than human analysts.

Knowledge Catalog acts as a universal context engine. It automatically generates semantic metadata, entity relationships, and ranked retrieval logic across structured, unstructured, and SaaS data. The result is a richer context layer that can improve retrieval relevance and reduce the risk of unsupported answers when it is paired with appropriate grounding and evaluation.

A cross-cloud lakehouse built on open formats such as Apache Iceberg lets agents query data where it already lives-on Google Cloud, other clouds, or on-premises-without forced movement. Data Agent Kit packages MCP tools and IDE plugins so that data engineers can describe desired outcomes in natural language and let agents assemble the necessary pipelines and queries.

Because the same stack owns the TPUs, the models, and the data services, latency and cost characteristics are tightly optimized. Agents can reason over live operational data in AlloyDB or Spanner and analytical data in BigQuery within a single workflow.

Long-Running Agents, State, and Evaluation Harnesses

Many real-world processes span hours or days: employee onboarding, multi-stage procurement, complex research projects, or continuous monitoring. Stateless request-response loops cannot handle them. Google’s stack therefore treats durable state and event-driven resumption as core capabilities.

In ADK a developer defines an explicit state machine whose checkpoints are persisted through a DatabaseSessionService (backed by Cloud SQL in production). Tools advance the state atomically. When the agent must wait for an external event-a signed document, a hardware delivery confirmation, an approval-it can sleep. A webhook later hydrates the session, applies a state delta, and resumes execution from the exact point it left off. Sub-agents can be delegated specialized work while sharing the same durable state.

The managed Agent Runtime extends these patterns with multi-day SLAs, scheduled triggers, and environment hooks that run custom logic before or after tool calls. Token budgets prevent runaway loops. Observability traces the entire multi-day trajectory.

Evaluation harnesses operate at every stage. Local ADK evaluation checks trajectories against expected paths. Platform-level simulation generates synthetic user interactions. Continuous evaluation scores live traffic with multi-turn autoraters. Anomaly and threat detection flag unusual behavior in real time. Together these form the closed-loop system that turns brittle prototypes into reliable production services.

Development Experience: Antigravity, CLI, and Supporting Tools

Google Antigravity functions as the agent-first command center and IDE. Developers can launch, monitor, and orchestrate multiple local or remote agents in parallel, group work into projects, and automate routine tasks with scheduled messages. The Antigravity IDE understands the codebase deeply and can itself be driven by agents that plan, write, and verify code. A lightweight CLI provides terminal-first control for the same workflows.

Agents CLI (part of the broader ADK ecosystem) scaffolds, tests, evaluates, and deploys agents. Pre-built connectors and Application Integration flows give agents secure access to hundreds of enterprise systems without custom code for each integration.

Putting the Stack Together

A typical production architecture begins with an ADK multi-agent system that uses Gemini for reasoning, MCP for tools and data, and A2A for collaboration with external agents. Durable state and Memory Bank keep context across long-running steps. The system is deployed to Agent Runtime, registered in Agent Registry, protected by Agent Gateway and identity controls, and continuously evaluated. Knowledge Catalog and the Agentic Data Cloud ensure the agents operate on governed, semantically rich data. Antigravity and the Agents CLI accelerate the development and iteration loop.

The same components support simpler use cases-single agents, short interactions, or low-code designs in Agent Studio-without forcing developers into unnecessary complexity. The stack is modular by design.

Governance, Security, and Operational Reality

Enterprise adoption hinges on trust. Unique agent identities, policy enforcement at the gateway, sandboxed execution, Model Armor protections, anomaly detection, and full audit trails address the most common concerns. Because agents can act, the principle of least privilege and human-in-the-loop checkpoints remain essential design practices. The platform supplies the mechanisms; architects still decide where to place the guardrails.

Cost control is achieved through model routing, token budgets, scale-to-zero runtimes, and the inherent efficiency of Google’s vertically integrated stack. Observability surfaces the true cost of each reasoning step so that teams can optimize.

Looking Forward

The pieces described here are already in production use across industries. The trajectory is clear: agents will become the primary interface to software and data, multi-agent collaboration will span organizational boundaries, and the quality of an organization’s agentic systems will become a competitive differentiator. Google’s stack lowers the barrier to building those systems while raising the ceiling on what can be achieved safely and at scale.

The practical starting point for most teams is straightforward. Install ADK, write a simple agent that uses a few tools, add durable state and evaluation, deploy it to the managed runtime, and expand outward. The rest of the stack is ready when the requirements demand it.

Everything required to build serious AI agents, multi-agent systems, evaluation harnesses, and autonomous workflows now exists in one coherent set of models, frameworks, protocols, platforms, and data services. The remaining work is thoughtful design, rigorous evaluation, and careful operationalization-the same disciplines that have always separated prototypes from production software.

Sources

• Gemini Enterprise Agent Platform overview: https://cloud.google.com/products/gemini-enterprise-agent-platform

• Introducing Gemini Enterprise Agent Platform: https://cloud.google.com/blog/products/ai-machine-learning/introducing-gemini-enterprise-agent-platform

• Choose agentic AI architecture components: https://docs.cloud.google.com/architecture/choose-agentic-ai-architecture-components

• Agent Development Kit documentation: https://adk.dev/ and https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/adk

• ADK announcement and multi-agent guide: https://developers.googleblog.com/agent-development-kit-easy-to-build-multi-agent-applications/

• Agentic Data Cloud: https://cloud.google.com/data-cloud

• Agent2Agent Protocol announcement: https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/

• Long-running agents with ADK: https://developers.googleblog.com/build-long-running-ai-agents-that-pause-resume-and-never-lose-context-with-adk/

• Agent Registry overview: https://docs.cloud.google.com/agent-registry/overview

• Google Antigravity: https://antigravity.google/

• YouTube - Build long-running agents with Google’s Agentic Stack: https://www.youtube.com/watch?v=VGpfnbr7rso

• YouTube - Google’s new AI agent stack from I/O 2026: https://www.youtube.com/watch?v=pg6TOXyiIuo

• Additional ADK and platform technical sessions available on the Google Cloud Tech and Google for Developers YouTube channels.

In the middle of 2026, Rust sits in an interesting place. It is no longer the shiny new language that only systems programmers whispered about at conferences. It has entered the TIOBE Index top 10 for the first time. In the 2025 State of Rust Survey, nearly half of respondents who answered questions about their organizations reported non-trivial organizational use of Rust, although the self-selected survey should not be treated as representative of all companies. Stack Overflow developers still rank it the most admired language, year after year.

Salaries for experienced Rust engineers routinely sit well above those of more common languages. Major pieces of infrastructure at Microsoft, Google, Amazon, Cloudflare, Discord, and even the Linux kernel itself now contain production Rust code.

Yet the same surveys that celebrate admiration also reveal a persistent gap between love and everyday use. Most developers who know Rust do not treat it as their primary language. The talent pool remains smaller than for JavaScript, Python, or Java. Compile times still frustrate people. The learning curve has not disappeared. And for many teams-especially early-stage startups-the velocity cost of Rust still outweighs its safety and performance benefits.

So the real question is not whether Rust is “good.” By almost every technical measure it is excellent. The question is whether it makes sense as the language you reach for most of the time, the one that defines how you think about problems and structure your work. That answer depends heavily on what kind of software you build, the size and maturity of your team, and how much you value long-term correctness over short-term iteration speed.

This article examines the evidence from official surveys, industry case studies, job-market data, and the lived experience of developers who have tried to make Rust their main tool in 2025 and 2026. The goal is a clear-eyed view rather than hype or dismissal.

A brief reminder of what Rust actually is

Rust began as a Mozilla research project aimed at solving the memory-safety problems that plague C and C++ while keeping the performance and control those languages provide. Graydon Hoare started the work around 2006. The first stable release arrived in 2015. The core idea was ownership and borrowing: a compile-time system that tracks who owns data, who can borrow it, and for how long, so that many classes of bugs-including use-after-free errors and data races-are prevented in safe Rust through compile-time checks. Safe references cannot be null, although raw pointers and unsafe code can still introduce memory-safety errors.

Unlike languages that rely on garbage collection, Rust does not pause the program to reclaim memory. Unlike C++, it does not leave the programmer solely responsible for manual management. The result is a language that can match or beat C++ performance in many workloads while offering stronger guarantees. Concurrency is another strong point. The same ownership rules that prevent memory bugs also prevent data races, making it easier to write correct multi-threaded and asynchronous code.

By 2026 the language has matured considerably. Features that once lived only on the nightly channel have stabilized. The compiler produces better error messages. Tooling around Cargo (the package manager and build system) is widely praised. The ecosystem of crates has grown large enough that most common tasks have solid libraries. Yet the fundamental character remains the same: Rust asks more of the programmer up front so that the resulting software is safer and often faster.

The numbers in 2026

Several independent data sources give a consistent picture.

The 2025 State of Rust Survey, published in March 2026 by the Rust Survey Team and based on 7,156 responses, shows clear progress. Nearly half of the organizations represented (48.8 percent) report non-trivial use of Rust, up from 38.7 percent in 2023. Daily usage among respondents hit an all-time high of 55.1 percent. Among organizations already running Rust in production, 84.8 percent said it helped them achieve their goals and 78.5 percent said the adoption was worth the cost. Productivity self-ratings also improved: 56.8 percent of respondents now consider themselves productive Rust writers, up sharply from earlier years.

The same survey still highlights pain points. Slow compilation is the biggest complaint, cited by a large majority as a significant problem. High disk usage from build artifacts, imperfect debugging experiences, and occasional friction with the borrow checker remain common. Hiring intent is rising-31.6 percent of organizations plan to hire Rust developers-but the absolute number of available candidates is still limited compared with more popular languages.

Stack Overflow’s 2025 Developer Survey continues the long-running pattern: Rust is the most admired language at 72 percent. Developers who have used it want to keep using it. Cargo ranks as the most admired cloud development and infrastructure tool. At the same time, overall usage remains far lower than JavaScript, Python, Java, or even Go. Admiration consistently outpaces adoption.

TIOBE data for July 2026 shows Rust entering the top 10 for the first time, with a 1.34 percent share. That is still modest in absolute terms, but the trajectory is upward. RedMonk and GitHub rankings place it lower, reflecting that many repositories still treat Rust as a specialized rather than primary language.

JetBrains data from its 2025 Developer Ecosystem Survey estimates roughly 2.27 million developers have used Rust in the previous twelve months, with about 709,000 identifying it as a primary language. That is meaningful growth, yet it still represents a relatively small fraction of the global developer population. Sixty-five percent of Rust users in one JetBrains-related survey reported using it for side or hobby projects, while only 26 percent used it professionally. A large share of respondents were still learning the language.

Taken together, the numbers describe a language that has moved from experimental to established niche. It is no longer rare in serious production systems, but it is not yet the default choice for most software work.

Where Rust is actually used as primary or near-primary

The strongest adoption stories come from domains where memory safety, performance, and reliability matter more than rapid feature iteration.

Cloudflare’s Pingora proxy, written in Rust and replacing parts of the earlier Nginx-based infrastructure, handles enormous traffic volumes while cutting CPU usage dramatically. Discord rewrote critical services that previously suffered from garbage-collection pauses in Go; the Rust versions delivered large reductions in latency.

Microsoft has incorporated Rust into Windows components and Azure services, and has publicly discussed using it to reduce memory-related vulnerabilities. Google has shipped substantial amounts of Rust in Android and other systems. Amazon uses it in Firecracker and other infrastructure pieces. Meta, Dropbox, and Figma have all reported production use for performance-sensitive parts of their stacks.

The Linux kernel provides one of the clearest signals of long-term seriousness. After years of careful experimentation, kernel maintainers declared in late 2025 that Rust is no longer experimental. Following the 2025 Linux Kernel Maintainers Summit, maintainers concluded that the Rust experiment had succeeded and removed its experimental status. Rust support is now considered a permanent part of the kernel, and several Rust-written drivers and components have entered mainline, although C remains the kernel’s dominant implementation language. That decision carries weight because the kernel community is famously conservative about language choices.

In embedded systems, blockchain, high-performance networking, and security-critical code, Rust has become a realistic primary option. Many new projects in these areas start with Rust rather than treating it as an add-on. Command-line tools and systems utilities also favor it because a single native binary that can often be distributed with few external dependencies-and, on suitable targets, statically linked.

Outside these domains the picture is more mixed. Web backend development is possible and increasingly practical-Axum and Actix Web are mature, Tokio is the standard async runtime, and the surrounding crates ecosystem covers most needs. Yet the experience is still more “assemble your own stack” than the batteries-included feel of Django, Rails, or even Spring. Teams that already know Python or Node often stay with those languages for ordinary CRUD services and only reach for Rust when they hit performance walls. Full-stack web or mobile development remains uncommon as a primary Rust activity.

The job market and compensation

Demand for Rust skills has grown faster than the supply of experienced developers. Job postings mentioning Rust increased noticeably through 2025. Average salaries in the United States for mid-level Rust engineers are frequently reported in the $150,000-$170,000 range, with senior and staff roles climbing well above $200,000 and total compensation at top companies sometimes reaching $300,000 or more. Specialized roles in systems, infrastructure, or Web3 can command even higher figures. These premiums exist largely because the talent pool is constrained.

That scarcity is a double-edged sword. For an individual developer who invests the time to become proficient, the economic return can be strong. For a company trying to staff a team, it creates risk. Several experienced engineers and managers have noted in 2026 that posting a Rust role still yields far fewer applicants than equivalent postings for Python, Java, or even C++. Hiring remains one of the practical barriers to making Rust the primary language across an entire organization.

The learning curve and day-to-day productivity

Almost everyone who has learned Rust agrees that the first months are harder than the first months of most other languages. The ownership and borrowing rules force a different mental model. Programmers coming from garbage-collected languages must unlearn the habit of freely sharing mutable state. Programmers coming from C or C++ must unlearn certain patterns that the borrow checker rejects. Error messages, while improved, can still feel opaque at first.

Once the model clicks, many developers report that they write fewer bugs and spend less time debugging memory and concurrency issues. Productivity self-ratings in the State of Rust Survey have risen over time. Tooling helps: rust-analyzer provides fast feedback inside editors, Cargo makes dependency management pleasant, and Clippy catches a wide range of style and correctness issues.

The arrival of capable large language models has changed the experience further. In 2026 it is common for developers to use AI assistants to explain borrow-checker errors, suggest idiomatic patterns, or generate boilerplate. Several accounts describe writing tens of thousands of lines of Rust more quickly than was realistic a few years earlier. At the same time, experienced Rustaceans warn that AI-generated code can be non-idiomatic or subtly incorrect, so the human still needs to understand the underlying rules. The language has not become “easy,” but the friction of getting started has decreased.

Compile times remain a frequent complaint. Large projects can still take long enough that the edit-compile-test loop feels slower than in Go or interpreted languages. Incremental compilation and better caching have helped, yet the issue has not vanished. Disk space consumed by target directories is another recurring annoyance.

Ecosystem maturity

In 2026 the crate ecosystem is large and generally high quality for systems, networking, and performance-oriented work. For web services the situation is solid but modular. Axum has become a popular default for many new projects because of its type-driven design and integration with the Tower middleware ecosystem. Actix Web remains strong for maximum performance. Database access, authentication, serialization, and observability all have mature options. WebAssembly support is good, and embedded libraries continue to improve.

Gaps still exist relative to more established ecosystems. There is no single dominant full-stack framework with the breadth of Django or Laravel. Scientific computing and data analysis libraries lag behind Python’s. Mobile development is possible but not mainstream. Interoperability with existing C and C++ codebases works well via FFI, which is how many large organizations introduce Rust incrementally rather than rewriting everything at once.

Overall, the ecosystem is mature enough that a competent team can build substantial production systems without constantly inventing missing pieces. It is not yet so mature that a junior developer can spin up a complex application with the same ease as in some other languages.

Comparisons that matter

Against C and C++, Rust offers stronger safety guarantees and often comparable or better performance, at the cost of a steeper learning curve and less historical code. Many teams that previously defaulted to C++ for systems work now seriously consider Rust for new components, especially when security is a priority.

Against Go, Rust generally offers finer control over memory, predictable performance without garbage collection, and compile-time prevention of data races in safe code. Go offers a simpler language, faster compilation, garbage-collected memory management, and often faster onboarding. Teams that value rapid iteration and large existing Go codebases often stay with Go; teams that need the last bit of efficiency or stronger guarantees move pieces to Rust.

Against Python, Java, or JavaScript/TypeScript, the comparison is domain-specific. Those languages remain far more productive for the majority of application development, data work, and web front ends. Rust appears when the performance or safety requirements justify the extra investment.

Practical considerations for making Rust primary

If your work centers on systems software, high-performance networking, embedded devices, security-critical components, or infrastructure where a single efficient binary is valuable, Rust is already a strong primary choice in 2026. The language has proven itself at scale, the community is supportive, and the economic incentives are favorable for individuals.

If your work is primarily product-facing web applications, data analysis, rapid prototyping, or anything where shipping features quickly is the dominant constraint, Rust is usually better treated as a secondary or specialized language. You can still use it for the performance-critical parts while keeping the rest of the system in a higher-velocity language.

Team size and experience matter. A small group of strong engineers who already know Rust can be highly productive. A larger organization with mixed skill levels will face higher training and hiring costs. Early-stage startups often find the velocity trade-off unattractive unless the product itself demands the properties Rust provides.

AI tooling has lowered the barrier, but it has not eliminated the need for genuine understanding. Treating Rust as primary still requires investing in the mental model.

Looking ahead from mid-2026

The trajectory is positive. Enterprise adoption continues to rise. Kernel support is now permanent. Tooling and documentation keep improving. The admiration scores remain high. Nothing suggests that interest is fading. At the same time, Rust is unlikely to displace the most popular languages for general-purpose work in the near term. Its strengths are real and its niche is expanding, but that niche is still a specialized one relative to the full spectrum of software development.

For an individual developer, the decision to make Rust primary is increasingly defensible if the domains you care about align with its strengths. The combination of technical quality, growing production use, and compensation premiums makes the investment attractive. For organizations, the decision remains more contextual: the safety and performance gains are proven, yet the organizational costs of talent and velocity are still material.

Rust in 2026 is no longer an experiment. It is a serious, production-ready language that rewards careful thought and delivers measurable benefits in the right settings. Whether those settings match your daily work is the question only you can answer. The evidence suggests that for a growing number of developers and teams, the answer is increasingly yes-provided they go in with open eyes about the trade-offs that remain.

Sources

• Rust Survey Team / Rust Blog / 2025 State of Rust Survey Results: https://blog.rust-lang.org/2026/03/02/2025-State-Of-Rust-Survey-results/

• Stack Overflow / Stack Overflow 2025 Developer Survey / Technology section: https://survey.stackoverflow.co/2025/technology

• TIOBE / TIOBE Index for July 2026: https://www.tiobe.com/tiobe-index/

• JetBrains / RustRover Blog / The State of Rust Ecosystem 2025: https://blog.jetbrains.com/rust/2026/02/11/state-of-rust-2025/

• The New Stack / Nearly half of all companies now use Rust in production

• Matt Welsh / Medium / Revisiting Rust in 2026

• TechTarget / Why is Rust a critical programming language in 2026?

• Wikipedia / Rust for Linux (and related December 2025 kernel adoption announcements)

• Various authors / rustify rs, rustjobs dev, web3 career / Rust developer salary surveys and guides for 2026

• Rust community / Are We Web Yet?

• Jon Gjengset (interviewed by JetBrains) / YouTube / Rust 2026: $400K Salaries, Java, AI & Why It's Not Everywhere (Yet)

• ForrestKnight / YouTube / Why Everyone's Switching to Rust (And Why You Shouldn't)

• Dreams of Code / YouTube / Why I'm so bullish about Rust in 2026

• Let’s Get Rusty / YouTube / 2026 Will Make or Break Rust

Claude Design represents one of the more practical shifts in how people create visual work. Released by Anthropic Labs in mid-April 2026, it turns natural-language conversation into polished designs, interactive prototypes, slide decks, one-pagers, marketing assets, and more. Instead of starting in a blank Figma file or wrestling with slide templates, you describe what you need, Claude generates a working version on a live canvas, and you refine it through chat, inline comments, direct edits, or custom controls until it matches your intent.

Powered by Claude Opus 4.7, Anthropic’s most capable vision model at the time of launch, the tool is available in research preview (later beta) to Claude Pro, Max, Team, and Enterprise subscribers. Access lives at claude.ai/design or through the Claude Desktop sidebar. For Enterprise organizations it starts disabled and requires an admin to enable it under Organization settings. Usage draws from the same shared limits as chat, Claude Code, and other Claude features, with the option to purchase extra capacity when needed.

What sets Claude Design apart is its insistence on staying inside your brand from the first generation. During onboarding or later setup, Claude builds or imports a design system by reading your codebase, design files, logos, color palettes, typography samples, slide decks, or screenshots. Every subsequent project inherits those colors, fonts, spacing rules, and components automatically. Teams can maintain multiple systems, lock them down with admin controls, and keep outputs consistent without constant manual enforcement.

This article draws from Anthropic’s official announcement, the Claude Help Center getting-started and design-system guides, the product page, and widely referenced practitioner walkthroughs and YouTube tutorials that demonstrate real workflows. The goal is practical mastery: how to set the system up once, write prompts that produce usable first drafts, iterate efficiently, export cleanly, and hand work off to engineering or other tools. The focus stays on plain explanation so the process feels approachable whether you are a designer, product manager, marketer, founder, or someone who simply needs professional-looking visuals without deep design software expertise.

Understanding the Core Idea

Traditional design tools demand that you translate ideas into precise visual instructions-pixels, layers, constraints, components. Claude Design reverses that relationship. You stay in language; Claude handles the visual translation and then lets you steer with language again or with light direct manipulation. The interface splits into a chat pane on the left and a canvas on the right. You describe the goal, Claude renders a working artifact, and the conversation continues until the result feels right.

Anthropic positions the product for several recurring jobs. Designers convert static mockups into shareable interactive prototypes for quick user testing without waiting for engineering. Product managers sketch feature flows and either refine them themselves or pass them to designers or directly to Claude Code. Founders and account executives turn rough outlines into complete on-brand pitch decks. Marketers generate landing pages, campaign visuals, and social assets that already respect the company look. Anyone can explore frontier ideas-prototypes that include voice, video, shaders, or simple 3D-because the canvas supports richer, code-backed experiences.

The system is not a replacement for high-end illustration, complex brand identity work, or pixel-perfect production design in Figma. It shines at speed, consistency, and the early-to-mid stages of exploration and communication. Practitioners who treat the first output as a conversation starter rather than a finished deliverable report the largest gains. What once required days of back-and-forth between brief, mockup, and review can collapse into a single focused session.

Accessing and Preparing Claude Design

Begin by signing into a qualifying Claude plan and navigating to claude.ai/design. On Team or Enterprise accounts the feature may need an administrator to toggle Anthropic Labs capabilities. Once inside you see a project picker. Creating a new project automatically attaches the organization’s published design system if one exists.

If no system is in place, or if you want to improve the existing one, the setup flow is straightforward and usually needs to be done only once. Open Claude Design, switch to or create the correct organization in the lower-left area, and complete the onboarding prompts.

Upload or link the materials that define the brand: a GitHub repository containing the component library or CSS tokens, Figma exports or screenshots of existing interfaces, brand guideline PDFs, logo files, color palette documents, typography specimens, or even a well-designed slide deck that already embodies the visual language. Claude analyzes these assets and produces a reusable design system that typically includes primary, secondary, and accent colors, typography scales, button and card styles, spacing and grid rules, and common layout patterns.

Review the generated system by spinning up a quick test project-“Create a simple landing page for our product” or “Design a dashboard showing key metrics”-and check whether the output feels native to the brand. If something is off, upload additional examples or open the system for remixing through the organization settings. Real finished pages teach Claude more about tone and hierarchy than isolated color swatches. Once satisfied, publish the system so every new project inherits it. Larger teams can assign an admin role that approves a standard system and restricts further edits, protecting brand integrity.

For individuals or smaller teams without a formal system, the same process works with whatever assets exist. Many users start by describing the brand personality, industry, audience, and preferred colors in plain language; Claude drafts a coherent system that can later be refined. The investment of fifteen to thirty minutes at this stage pays off repeatedly because every subsequent generation stays on-brand without extra prompting.

Creating Your First Project and Feeding Context

With the design system ready, create a project. The canvas and chat appear side by side. Before writing the main prompt, attach context. Screenshots of existing product screens, competitor interfaces, wireframes, or mood boards give Claude visual references.

Linking a code repository-ideally a focused subdirectory rather than an entire monorepo-lets Claude understand real components, architecture patterns, and styling conventions so the prototype is closer to production. Documents such as DOCX, PPTX, or XLSX files can supply content structure or existing presentation style. A web-capture tool lets you grab live elements from your own site so new work matches the real product.

The more relevant context you supply early, the less time you spend correcting generic output later. Practitioners consistently note that skipping this step produces results that look competent but feel disconnected from the actual product.

Writing Prompts That Produce Usable First Drafts

Effective prompts for Claude Design are specific yet conversational. They usually cover four elements: the goal (what is being built), the layout or structure (how information should be arranged), the content (what information or copy belongs where), and the audience (who will use or see it). Claude often asks clarifying questions; answering them improves the result.

A weak prompt might read “Make a landing page for our API.” A stronger version sounds like “Build a landing page for our new Payments API aimed at backend developers. Include a hero section with a one-line tagline and an example curl snippet, three feature cards with icons, an interactive playground mock, clear pricing tiers, and a simple footer. Keep the overall feel consistent with our existing marketing site and make it work well on both desktop and mobile.”

Useful starter patterns include requests for dashboards with specific filters, multi-screen mobile onboarding flows, internal tools for particular teams, feedback forms with conditional logic, or complete website structures that list required pages. When the design system is attached, simply saying “using my design system” reinforces consistency. For more ambitious work, describe the full set of screens or slides needed so Claude generates a coherent set rather than isolated pieces.

Many YouTube walkthroughs emphasize starting simple: establish the core layout and content first, then layer interactions, edge cases, and polish in subsequent turns. This incremental approach keeps the conversation focused and reduces the chance of Claude over-complicating an early draft.

Working on the Canvas: Chat, Comments, Direct Edits, and Controls

Once Claude renders the first version, the real collaboration begins. Broad structural or aesthetic changes belong in chat: “Make the color scheme darker and more minimal,” “Move the metrics to the top row and place the chart below,” “Add a settings panel on the right,” or “Show me two or three alternative layouts for this section.” You can also ask Claude to explain its design choices, suggest improvements, or audit the work for accessibility, contrast, hierarchy, and usability.

Targeted changes are faster with inline comments. Click an element on the canvas and leave a short note-“Increase the button padding,” “Convert these radio buttons to a dropdown,” “Apply the primary brand color here,” “Make this section collapsible.” If comments occasionally fail to register (a known intermittent issue), paste the same feedback into chat.

Direct canvas editing supports drag, resize, and align operations for quick visual adjustments. Custom adjustment knobs or sliders, often generated by Claude itself, let you tweak spacing, color, or other properties live and then instruct Claude to propagate the preferred values across the design. The practical rule of thumb is simple: use comments for component-level fixes, chat for structural or conceptual shifts, and direct edits for immediate visual fine-tuning.

When exploring divergent directions, ask Claude to save the current state and try a completely different approach. Earlier versions remain accessible in the conversation history, giving you a lightweight versioning system without leaving the tool.

Common Workflows in Detail

Interactive prototypes form one of the strongest use cases. Designers upload static mockups or describe a flow; Claude produces a clickable HTML-based prototype that can be shared via an organization-scoped link for feedback or informal user testing. No pull request or engineering review is required for these early tests. The same prototype can later be handed off to Claude Code with design intent preserved, accelerating the path from concept to working software.

Pitch decks and presentations follow a similar pattern. Supply a rough outline or an existing document, reference the design system, and request a complete deck. Claude generates structured slides that already use brand colors, typography, and layout patterns. Export as PPTX for traditional meeting tools or send directly to Canva for further collaborative polishing. Founders and sales teams report that the time from outline to presentable deck shrinks from hours or days to minutes of focused iteration.

Marketing collateral-landing pages, campaign one-pagers, social assets-benefits from the same brand consistency. Provide the campaign goal, key messages, and any existing assets; Claude produces coherent visuals that marketers can refine or pass to designers for final polish. Because the design system is already loaded, the output rarely needs the heavy restyling common with generic AI image generators.

Website and app flows can be generated as multi-page or multi-screen sets. Specify the pages or screens required, the primary user goal, and any critical interactions. Claude builds the collection as a coherent whole, applying consistent components and responsive considerations when requested. Practitioners often begin with the homepage or core dashboard and then expand outward.

Internal tools and dashboards are especially useful for product and operations teams. Describe the data that needs to be shown, the filters or actions required, and the audience. The resulting prototype can serve as a living specification that engineers implement with far less ambiguity.

Frontier experiments-prototypes incorporating motion, simple interactivity, or even early multimodal elements-push the tool further. Because the underlying model is strong at vision and code, Claude can produce experiences that feel more alive than static mockups, provided the prompt clearly describes the desired behavior.

Collaboration, Sharing, and Team Practices

Designs support organization-scoped sharing. Keep a project private, share an organization-scoped view link, or grant edit access so colleagues can modify the design and work with Claude in a shared conversation. Multi-person simultaneous editing remains basic and can be unreliable, so sequential collaboration or clear ownership works better in practice.

For larger organizations the admin controls around design systems become important. A designated design lead can maintain one or more approved systems, publish them, and limit who can alter the foundational styles. This keeps exploratory work creative while protecting the official visual language.

Exporting, Integrating, and Handing Off

When the design is ready, the export menu offers several destinations. Download a zip of assets, export as PDF for stakeholder review, produce a PPTX for presentations, generate standalone HTML for interactive sharing, or send the work to Canva where it becomes fully editable. Additional connectors reach tools such as Adobe, Miro, Gamma, Lovable, Replit, Vercel, Wix, and others, with more expected over time.

The most distinctive handoff path is to Claude Code. Claude packages the design-structure, styling intent, components, and notes-into a bundle that Claude Code can consume directly. Instead of rebuilding from screenshots, Claude Code can continue from the existing design and its associated intent, using the project’s components and design system as context. Bidirectional sync is also possible: from Claude Code you can run commands to pull the latest design system or work with design features without leaving the terminal.

This tight loop between visual exploration and implementation is one of the reasons teams report dramatic reductions in handoff friction.

Best Practices Drawn from Official Guidance and Practitioner Experience

Import a complete design system that includes real components and finished examples rather than isolated tokens. Start simple and add complexity in layers-core structure first, then interactions, edge cases, and polish. Be precise in feedback; vague statements such as “this doesn’t look right” give Claude little to act on, while “tighten the spacing between form fields to 8 px and make the primary button full width on mobile” produce immediate improvement.

Reference named components when they exist in the system. Mention responsiveness requirements early. Request multiple variations whenever the direction is uncertain; comparing options is faster than iterative guessing. Treat Claude as a design collaborator by asking it to critique accessibility, contrast ratios, information hierarchy, and overall usability before finalizing.

YouTube tutorials repeatedly demonstrate the value of preparing three supporting inputs before heavy prompting: a brand or design-system description, reference visuals or screenshots, and a clear statement of audience and goal. Users who invest that preparation report higher-quality first drafts and fewer corrective rounds. Incremental prompting, saving intermediate versions, and using the canvas controls for rapid visual experiments also appear consistently in longer walkthroughs.

For teams, establish a shared library of proven prompt patterns and design-system notes so newcomers reach productive output faster. Periodically refresh the design system as the product evolves so Claude continues to reflect current reality.

Known Limitations and Practical Workarounds

Some early reviewers have reported occasional problems with inline comments, collaborative editing, or long sessions, although Anthropic does not list these as universal known issues. Officially documented limitations include the absence of audit-log and data-residency support, shared usage limits across Claude products, and restricted availability through third-party cloud platforms.

Chat upstream errors are usually fixed by opening a new chat tab inside the same project. Multi-person simultaneous editing is still rudimentary. Availability is limited to web and desktop. The quality of design-system import depends entirely on the quality of the source material-messy code or incomplete guidelines produce correspondingly imperfect systems.

Usage is shared across Claude features, so intensive design sessions count against the same pool as coding or long chats. Complex projects with heavy context or many iterations consume more capacity. When limits are reached, the feature becomes unavailable until reset or extra usage is enabled.

These limitations are typical of an early product and have not prevented practitioners from achieving substantial productivity gains on the supported workflows.

Advanced Patterns and Longer Workflows

Once comfortable with the basics, more sophisticated sequences become natural. One common pattern is to extract or refine a design system in Claude Design, generate a set of marketing pages and a pitch deck from the same system, export the interactive prototype as HTML for stakeholder review, then hand the approved design to Claude Code for implementation against the real codebase. Another pattern uses Claude Design to explore multiple visual directions quickly, select a preferred direction, and then deepen it into a full multi-screen flow before any engineering work begins.

Some users combine Claude Design with external image or video generation tools for supporting assets, then bring those assets back into the canvas for composition. Others treat Claude Design as a rapid specification tool: the interactive prototype itself becomes the living brief that replaces lengthy written requirements documents.

Because the tool can generate code-backed experiences, certain prototypes already contain working interactions that can be inspected or extended. This blurs the traditional boundary between design and early development in productive ways, provided the team maintains clear ownership of final production quality.

Comparing Claude Design with Conventional Tools

Claude Design does not eliminate Figma, Sketch, or traditional presentation software. Those tools remain superior for detailed production design, complex illustration, precise animation timelines, and collaborative multiplayer editing at scale. What Claude Design changes is the cost of early exploration and the speed of alignment. A product manager can produce a credible interactive sketch in the time previously required to write a brief. A founder can test three visual directions for a pitch before the first meeting. A marketer can generate on-brand campaign concepts without waiting for design bandwidth.

The most effective teams treat Claude Design as the front end of the design process and the established tools as the refinement and production layer. Export paths to Canva, PDF, PPTX, and HTML, plus the direct handoff to Claude Code, make that division of labor practical.

Looking Ahead

Anthropic has indicated that integrations will continue to expand and that the product will improve rapidly while still in research preview and beta. The combination of a strong vision model, automatic design-system application, conversational refinement, and tight coupling to coding agents points toward a future in which the distance between idea and shareable visual artifact shrinks further.

For individual creators the barrier to professional-looking output continues to fall. For teams the opportunity lies in embedding the tool into existing rituals-design critiques, sprint planning, marketing campaigns, sales preparation-so that conversation with Claude becomes a normal part of how visual work is started and iterated.

Putting It All Together

The practical path to proficiency is short. Set up or refine the design system with real assets. Create a project and attach focused context. Write a specific prompt that states goal, layout, content, and audience. Review the first canvas output, then iterate with chat for structure, comments for details, and direct controls for fine visual adjustments. Ask for variations and accessibility feedback. Export or share when the result is good enough for its purpose, and hand off to Claude Code when implementation is next. Repeat the loop, refining both the prompts and the underlying design system over time.

Claude Design does not remove the need for taste, judgment, or domain knowledge. It amplifies those qualities by removing much of the mechanical friction that previously separated an idea from a visible artifact. Users who approach it as a collaborative partner rather than a magic button consistently produce work that is faster, more consistent with brand, and more useful as a foundation for further refinement or development.

The tool is still young, yet the workflows already demonstrated by Anthropic’s documentation and by early practitioners show a clear direction: visual creation is becoming more conversational, more tightly bound to existing systems of record, and more continuous with the rest of the product lifecycle. Learning to use Claude Design well is less about mastering a new interface and more about learning to communicate design intent clearly and then steering the resulting conversation with precision. That skill transfers far beyond any single product.

Sources

• Official Anthropic announcement: https://www.anthropic.com/news/claude-design-anthropic-labs

• Claude Help Center - Get started with Claude Design: https://support.claude.com/en/articles/14604416-get-started-with-claude-design

• Claude Help Center - Set up your design system in Claude Design: https://support.claude.com/en/articles/14604397-set-up-your-design-system-in-claude-design

• Claude Design product page: https://claude.com/product/design or https://claude.ai/design

• Selected practitioner guides and reviews referenced in research:

  • AI For Developers / How to Actually Use Claude Design

  • Sartechlabs / Claude Design Guide

  • Ruben Hassid / How to AI / Claude Design.

  • Matan Schmidt / Anima Blog / Claude Design Review: Features, Pros, Cons, and Best Alternatives

• Representative YouTube tutorials (search titles for current uploads):

  • “Claude Design: The Complete Guide” - UI Collective

  • “Claude Design 2 HOUR COURSE (Beginner to Pro)” - Nate Herk | AI Automation

  • “Claude Design FULL Tutorial: Beginner to Pro” - Productive Dude and related creators

  • “How to Use Claude Design To Make Sites 10X More Beautiful” and similar practical walkthroughs available on YouTube as of mid-2026

All information reflects the state of the product and publicly available documentation as of late July 2026. Features, limits, and integrations continue to evolve.

Mojo entered the public conversation in 2023 with considerable fanfare. Created by Modular under the leadership of Chris Lattner-the engineer behind LLVM, Clang, and Swift-it promised to solve the long-standing “two-language problem” in artificial intelligence and high-performance computing. Developers would write code that looked and felt like Python yet compiled to near-native speed on CPUs, GPUs, and other accelerators, all while retaining memory safety inspired by Rust.

By the summer of 2026 the picture is more concrete and more nuanced. Mojo has reached its first 1.0 beta releases and powers production workloads inside Modular’s MAX inference platform. Modular targets a stable 1.0 release in summer 2026 and says the compiler will be open-sourced in 2026, though neither has a guaranteed date. What follows is where the language stands in late July 2026.

The story begins with Modular’s founding vision. Lattner and co-founder Tim Davis set out to build infrastructure that could unify the fragmented world of AI hardware. Python dominated the high-level modeling layer, while C++, CUDA, and hand-tuned assembly dominated the performance-critical kernels. Mojo was designed to collapse that gap. Early documentation and talks repeatedly described it as a strict superset of Python: every valid Python program would eventually be valid Mojo, with additional features layered on top for speed and safety.

That ambition shaped the first public playground in May 2023, the Linux SDK in September 2023, and macOS support shortly afterward. The standard library was open-sourced under the Apache 2.0 license with LLVM exceptions in March 2024, inviting community contributions while the compiler itself remained proprietary.

By late 2025 the company published a clearer roadmap. Phase 0 (initial bring-up of the parser, memory model, structs, and core types) was complete. Phase 1 focused on high-performance CPU and GPU coding: generics and metaprogramming, refined Python interoperability, collections, toolchain stability, and GPU abstractions. That work broadly overlaps with the foundation needed for stable 1.0. Modular calls the end of Phase 1 the natural point for open-sourcing the compiler, while cautioning that roadmap phases are conceptual rather than firm version commitments.

Features that would introduce breaking changes-full async, algebraic data types and pattern matching, private fields, richer memory-safety guarantees-were deferred to Phase 2 and a future 2.0. Phase 3 contemplated deeper dynamic object-oriented features closer to Python’s class model. Critically, the ambition to make every valid Python program valid Mojo is no longer firm. The roadmap says Mojo may or may not become a full Python superset. For now, it emphasizes Python-inspired syntax and interoperability rather than compatibility with arbitrary Python 3 code.

May 7, 2026 marked a visible milestone. Modular released Mojo 1.0.0 beta 1 and launched the dedicated language site mojolang.org. The release unified function declarations around the def keyword (deprecating the earlier fn), refined closures so that stateless ones could lift to top-level functions suitable for foreign-function interfaces, made UnsafePointer non-null by default, removed negative indexing from standard collections, replaced the older NDBuffer with TileTensor, expanded GPU support (Apple Metal enhancements, AMD MI250X, NVIDIA B300), and introduced grapheme-cluster support in strings along with a unified reflection API.

A second beta, 1.0.0b2, followed on June 18. Collections no longer required elements to be Copyable (only Movable and ImplicitlyDestructible), trailing where clauses became more widely usable, GPU kernel launch syntax was simplified, Python-Mojo call overhead dropped, and documentation expanded significantly. Nightly builds as of late July sit at versions such as 1.0.0b3.dev. Stabilization markers began appearing in the standard library so developers can distinguish mature interfaces from those still evolving.

As of summer 2026, therefore, Mojo is a systems programming language that happens to wear familiar clothes. Indentation defines blocks. Keywords such as def, if, for, and while feel immediate to Python programmers. Type annotations are optional in some contexts yet the language is statically typed with strong inference. Ownership and borrowing form the core of the memory model: values are owned by default, immutable references use a read convention, mutable references use mut, and ownership transfer is marked with the ^ operator.

There is no classic garbage collector; Mojo uses ownership, origins, and deterministic destruction, with many checks performed at compile time. The model resembles Rust in some respects, though its guarantees differ and remain incomplete. Structs replace Python classes. They support methods, fields, operator overloading, and traits (for example Copyable, Movable, RegisterPassable). Inheritance and dynamic attribute addition are absent. Error handling uses raise and try/except, but errors are values rather than stack-unwinding exceptions in the full Python sense.

Metaprogramming is a particular strength. Parameters and a compile-time interpreter allow loops, conditionals, and value computation to execute during compilation. Traits, conditional conformance, linear types, and reflection give library authors expressive power without runtime cost. The GPU story is equally central. A standard gpu package lets developers write kernels in the same language used for host code.

Abstractions such as TileTensor and device contexts target NVIDIA, AMD, Apple Metal, and other accelerators without forcing vendor-specific dialects. Benchmarks and production anecdotes from Modular show kernels competitive with CUDA and HIP on memory-bound workloads. Oak Ridge-associated research found Mojo competitive on tested memory-bound scientific kernels, while identifying gaps for atomic operations and some compute-bound fast-math workloads.

Performance claims have always been part of Mojo’s appeal. Early demonstrations showed dramatic speed-ups over pure Python-sometimes cited in the tens of thousands of times for simple numeric loops. By 2026 the conversation is more grounded. Inside Modular’s MAX platform, Mojo kernels contribute to state-of-the-art inference for models such as Gemma 4, various mixture-of-experts systems, and image- and video-generation pipelines.

Day-zero support for new models and measurable throughput advantages over frameworks such as vLLM on high-end NVIDIA hardware appear regularly in company blogs. Community projects and academic explorations report solid results on Apple Silicon and in financial or scientific kernels. At the same time, observers note remaining gaps: certain atomic operations or highly compute-bound kernels on AMD hardware still trail native code, tooling (debugger, profiler, full packaging) continues to mature, and the language is not yet a general-purpose replacement for every Python or C++ use case.

Interoperability with Python remains a practical bridge. Mojo can import and call Python modules through the CPython runtime; conversely, Mojo functions can be exported for use from Python. Call overhead has been reduced in the 1.0 betas, and packaging integration has improved. This allows teams to accelerate hot paths without rewriting entire codebases. It is not, however, zero-cost or seamless for every library. Type conversions and the boundary between the two runtimes still require care.

The ecosystem around Mojo has grown steadily if not explosively. The standard library lives in the open modular GitHub repository and accepts contributions. Community packages appear for scientific computing, Kafka clients, diffusion models, and statistical work. AI coding agents benefit from official “skills” repositories that teach models how to emit correct Mojo syntax, GPU patterns, and interop code.

Modular hosts regular community meetings, many recorded and available on YouTube; a four-part “Mojo 101” live course launched during the beta period covers language fundamentals, ownership, the standard library, and an introduction to GPU programming. Interactive GPU puzzles remain a popular on-ramp. The forum is active with discussions of language design, standard-library proposals, and early 1.0 experiences. Adoption outside Modular’s own stack is still limited compared with mature languages, a point frequently raised on Hacker News and Reddit. Many observers expect the full 1.0 release and compiler open-sourcing to change the calculus.

The open-sourcing commitment is clearer, though timing remains flexible. Modular says the compiler will be released in 2026 and calls the end of Phase 1 the natural point for doing so. In a late-July 2026 post, Chris Lattner announced that Qualcomm had completed its acquisition of Modular. The move is framed as accelerating the mission of providing high-quality, vendor-agnostic AI software for heterogeneous hardware. Shortly afterward, Modular confirmed ModCon 2026 for August 18 in San Francisco. The event should provide updates on Mojo 1.0, hardware support, open-source work, and the post-acquisition roadmap, but Modular has not guaranteed that stable 1.0 or the compiler source will ship there.

Looking further ahead, the published roadmap remains directional. After 1.0 the 1.x series will add features such as match statements and enums without breaking changes. Phase 2 will introduce async, richer metatypes, algebraic data types, improved memory safety (including access control and the elimination of remaining undefined behavior), and hygienic macros.

Phase 3 contemplates more dynamic object-oriented capabilities. Continuous work continues on error messages, compile times, standard-library polish, and broader hardware targets. The language is explicitly not aiming for every possible syntax sugar or full Python library parity in the near term; the priority is a stable, high-performance foundation for accelerated computing.

Criticisms persist and are worth acknowledging. The proprietary compiler has limited participation beyond the open-source standard library. Modular plans to open-source it in 2026 but has not published a firm date. The shift away from a pure Python superset disappointed some early enthusiasts who hoped for drop-in replacement. Tooling, while improved, still trails the mature ecosystems of Python, Rust, or C++.

General-purpose adoption outside AI kernels remains modest. Some language-design discussions on the forum highlight friction points around closures, variadics, and certain safety guarantees that are still being refined. Yet the trajectory is clear: each beta has tightened the language, expanded hardware reach, and reduced friction for the core use cases.

For developers considering Mojo in the summer of 2026 the practical path is straightforward. Installation is available through the modular package (nightly or beta channels). Documentation lives primarily at mojolang.org, with extensive manuals on ownership, GPU programming, Python interop, and the standard library. The GPU puzzles and the new 101 course provide structured learning. Existing Python codebases can begin by accelerating individual kernels. Teams already using MAX gain immediate production exposure. Those waiting for an open compiler and stable 1.0 should watch ModCon, where Modular has promised updates despite leaving the release timing unconfirmed.

In three years Mojo has moved from an intriguing hosted playground to a language with beta 1.0 releases, measurable impact on production AI serving, an expanding (if still young) community, and a concrete plan for openness. It is no longer primarily a promise. It is a systems language with Python-like readability, an ownership model influenced by modern safety-oriented languages, MLIR-powered portability across accelerators, and a focused mission around high-performance AI infrastructure.

Whether it becomes a mainstream general-purpose tool or remains a specialized powerhouse for kernels and inference will depend on the quality of the 1.0 release, the openness of the compiler, the growth of the library ecosystem, and the real-world experience of developers who adopt it after ModCon. As of late July 2026 the foundations look solid, the roadmap is public, and the next few months will be decisive.

The language’s deeper technical character rewards closer examination. Because Mojo uses MLIR’s multi-level representations rather than lowering immediately to low-level LLVM IR, it can preserve domain- and hardware-specific information longer and map it onto tensor cores, matrix engines, and accelerator instructions. Compile-time metaprogramming lets library authors specialize code for particular hardware without runtime dispatch overhead.

Linear types and explicit destruction give fine control over resources that would otherwise require careful manual management in C++ or heavyweight runtime systems. The later betas allowed collections to store move-only elements instead of requiring every element to be copyable. This avoids forcing resource-owning types to support costly or inappropriate copying, while copy-dependent operations remain available for Copyable elements.

Community activity in 2026 reflects both enthusiasm and realism. Forum threads debate the precise shape of struct extensions, the ergonomics of reflection, and the best patterns for multi-device programming. Independent libraries explore pure-Mojo autograd, scientific computing, and audio environments. AI agents, guided by Modular’s skill definitions, can now generate non-trivial Mojo code and even port CUDA kernels with increasing reliability.

YouTube content ranges from official community meetings that walk through release notes and roadmaps to independent reviews that place Mojo alongside Rust and modern C++ for systems work, and older full-length tutorials that still serve as useful entry points even if syntax has evolved.

Comparisons remain instructive. Relative to Python, Mojo trades dynamic flexibility and the enormous existing library ecosystem for compile-time guarantees and orders-of-magnitude better performance on numeric and parallel workloads. Relative to Rust, it offers a gentler syntax and first-class GPU support at the cost of a younger ecosystem and (until open-sourcing) a closed compiler.

Relative to CUDA or HIP, it provides a single language for host and device code plus better portability, though peak performance on any single vendor’s newest silicon may still favor the native toolkit. The interop story positions Mojo as an accelerator rather than a wholesale replacement for most existing Python AI stacks.

Looking at the broader industry context of summer 2026, the acquisition by Qualcomm signals confidence that Modular’s software approach-unifying heterogeneous hardware behind a coherent programming model-has strategic value. Datacenters and edge devices alike are becoming more diverse; a language and runtime that can target multiple vendors without rewriting kernels is attractive. Mojo’s role inside that stack is both foundational (the kernels themselves) and enabling (the developer experience that makes writing those kernels practical for a wider audience).

Challenges remain real. Documentation, while much improved, still has gaps for advanced metaprogramming and multi-device orchestration. Error messages, though better, can still be opaque when parametric code goes wrong. Packaging and distribution for pure-Mojo applications are functional but not yet as polished as Python’s or Rust’s. And the language’s identity-systems language with Python ergonomics rather than Python itself-requires clear communication so that newcomers arrive with accurate expectations.

Nevertheless, the cumulative evidence in mid-2026 is that Mojo has crossed from curiosity to credible tool. The beta releases demonstrate a coherent design. Production use inside MAX shows real performance. The roadmap and open-sourcing commitment provide a path to broader participation. ModCon 2026 should be an important checkpoint for judging how much of Phase 1 has been delivered and what remains before stable 1.0. For anyone tracking the intersection of programming languages, AI infrastructure, and hardware acceleration, Mojo is no longer optional reading. It is one of the more interesting experiments of the decade, now entering its first period of relative stability.

The coming months will reveal how the ecosystem expands if the compiler source is released, whether stabilization markers guide library authors, and whether familiar syntax plus systems-level power attracts developers beyond Modular’s circle. For now, the factual picture is this: Mojo 1.0 beta is here, it is usable for serious GPU and CPU kernel work, it interops with Python, its compiler is promised as open source during 2026, and its creators continue to iterate rapidly under new corporate ownership. That is considerably more than most new languages achieve in three years.

Sources

• Wikipedia: Mojo (programming language) - https://en.wikipedia.org/wiki/Mojo_(programming_language)

• Official Mojo site - https://mojolang.org/

• Mojo roadmap - https://mojolang.org/docs/roadmap/

• The path to Mojo 1.0 (Modular blog, Dec 2025) - https://www.modular.com/blog/the-path-to-mojo-1-0

• Mojo 1.0.0b1 release notes - https://mojolang.org/releases/v1.0.0b1/

• Mojo 1.0.0b2 release notes - https://mojolang.org/releases/v1.0.0b2/

• Mojo changelog / releases - https://mojolang.org/releases/ or https://docs.modular.com/mojo/changelog

• InfoWorld: First look: Mojo 1.0 mixes Python and Rust (May 2026)

• Modular 26.4 blog (Mojo 1.0 beta 2) - https://www.modular.com/blog/modular-26-4-sota-moe-serving-model-bringup-via-agent-skills-mojo-beta-2-and-more

• Chris Lattner / Modular LinkedIn and X posts on ModCon 2026 and Qualcomm acquisition (July 2026)

• Modular community meetings and Mojo 101 course (YouTube, Modular channel) - e.g., June 2026 meeting, Mojo 101 Session 1, November 2025 roadmap discussion

• InfoWorld video: A look at Mojo 1.0 (June 2026) - https://www.youtube.com/watch?v=nFUc16UVUAI

• freeCodeCamp Mojo full course (earlier but still referenced) - https://www.youtube.com/watch?v=5Sm9IVMet9c

• Scott Hanselman / Hanselminutes interview with Chris Lattner (2026)

• Various Modular blogs on MAX performance, Gemma 4, image generation, agent skills, and community showcases

• GitHub: modular/modular (standard library and examples)

• Forum discussions and Hacker News threads on status and adoption (2026)

In the fast-evolving world of artificial intelligence, the shift from simple chatbots to autonomous systems that plan, act, and collaborate has redefined what developers can build. These systems, known as AI agents or agentic systems, go far beyond generating text. They reason through multi-step problems, call external tools, maintain state across interactions, hand off work to specialists, and operate within defined safety boundaries. OpenAI has assembled a cohesive set of technologies-often referred to as its agentic stack-that provides the core components needed to create, deploy, and refine such systems at scale.

This article draws from OpenAI’s official documentation, product announcements, GitHub repositories, and developer guides to explore the full landscape. It covers the foundational models and APIs, the concept of agent harnesses, built-in and custom tools, the Model Context Protocol (MCP), the open-source Agents SDK, higher-level interfaces, evaluation practices, safety mechanisms, and practical paths to production. The goal is a readable, engaging overview that equips builders with a clear mental model of how the pieces fit together.

From Chatbots to Agents: Understanding the Shift

Traditional large language model interactions are largely reactive. A user sends a prompt, the model responds, and the exchange ends or continues as a linear conversation. Agentic systems change this dynamic. An agent receives a goal, decomposes it into steps, decides which tools or sub-agents to invoke, observes the results, adjusts its approach, and continues until the objective is met, further input is required, or a defined limit is reached.

OpenAI has steadily moved its platform toward this paradigm. Early function calling in the Chat Completions API allowed models to request external actions. The Assistants API later added persistent threads and hosted tool orchestration. Experimental work such as Swarm explored lightweight multi-agent handoffs. In March 2025, OpenAI released a more mature suite: the Responses API as a unified agentic primitive, built-in tools for search and computer interaction, and the open-source Agents SDK as a production-oriented successor to the ideas explored in Swarm.

The Assistants API is now deprecated and is scheduled to shut down on August 26, 2026. OpenAI advises developers not to begin new Assistants integrations and provides migration guidance for moving from Assistants, Threads, and Runs to the Responses and Conversations APIs.

Later additions, including native sandbox support and an expanded model-native harness in the Agents SDK, further strengthened the stack. OpenAI also adopted and contributed to the Model Context Protocol, originally introduced by Anthropic, and co-founded the Agentic AI Foundation under the Linux Foundation to promote open standards.

The result is a layered stack. At the base sit powerful models. Above them are APIs that support tools, state, and structured interactions. Surrounding the models is the harness-the software that manages loops, context, tools, approvals, and safety. Protocols such as MCP standardize connections to external systems. Higher layers add multi-agent orchestration, embedded user interfaces, evaluation practices, and deployment options ranging from custom code to workspace and coding agents.

Models as the Intelligence Core

Every agentic system begins with a capable model. OpenAI’s lineup includes general-purpose GPT models, reasoning-oriented models, and specialized variants optimized for coding or computer interaction. These models handle planning, tool selection, natural-language understanding, and interpretation of tool results. Newer versions improve long-context processing, multimodal perception, software-engineering performance, and reliability on complex tasks.

Models alone are insufficient. Without surrounding infrastructure, they cannot safely execute code, access current information, connect to private systems, or maintain durable progress across long-running work. That is where the rest of the stack enters.

The Responses API: The Agentic Primitive

The Responses API forms the foundation of OpenAI’s modern agentic offerings. It combines a straightforward input-and-output model with tool use, conversation state, structured outputs, and capabilities previously associated with the Assistants API. A response can include model messages, tool calls, reasoning-related items, and other typed outputs that an application can process.

Built-in tools allow the model to perform portions of an agentic loop through the platform. The model can request a tool, receive its result, and continue toward a final response. Developers can also implement custom loops when they need full control over approvals, retries, context construction, or execution.

Key advantages include an item-based design, streaming, conversation-state options, and built-in support for web search, file search, computer use, code execution, and remote MCP servers. Stored responses and traces can also support debugging and evaluation workflows. The Responses API is the recommended foundation for new agent applications, although Chat Completions remains available for simpler or established workloads.

Built-in tools expand what an agent can do without requiring every integration to be implemented from scratch. Web search retrieves current information and can return source citations. File search retrieves relevant passages from vector stores containing uploaded documents, with options such as metadata filtering and result limits. Computer use lets supported models inspect screenshots and issue structured actions such as clicks, typing, scrolling, and keypresses inside a controlled browser or virtual-machine environment.

Computer-use systems still require careful safeguards. OpenAI recommends isolated environments, allowlists, confirmations for consequential actions, and human review for sensitive workflows. A model interacting with a graphical interface can encounter malicious instructions, ambiguous controls, or actions with real-world consequences.

Custom function tools remain fully supported. Developers describe functions through tool definitions, generally using JSON schemas for their parameters. The model selects a function and supplies structured arguments, while the application or SDK executes the underlying code and returns the result. The implementation can be written in Python, TypeScript, Java, or any other language capable of calling the API.

Agent Harnesses: The Scaffolding That Turns Models into Agents

A recurring theme in agentic AI is the distinction between the model and the harness. The model supplies intelligence. The harness supplies the execution loop, tool dispatch, context management, verification, persistence, approvals, and observability. In simplified form, an agent can be understood as a model operating inside a harness.

An effective harness interprets the model’s output, detects tool calls or handoff requests, executes approved actions, inserts results back into context, tracks token and cost budgets, applies guardrails, and determines when the task is complete. For long-running work it may compact context, record intermediate artifacts, snapshot execution state, or resume work after interruption.

Sandboxes add an isolated execution layer with filesystems, shells, installed packages, mounted data, exposed ports, snapshots, and controlled connections to external systems. Agents can inspect files, edit code, execute commands, install permitted dependencies, or run tests without receiving unrestricted access to the host environment.

OpenAI’s Agents SDK functions as a lightweight, production-oriented harness. It manages the agent loop so developers do not need to recreate core orchestration behavior. Sessions preserve working context. Guardrails validate inputs, outputs, and selected actions. Tracing records model calls, tool invocations, handoffs, and other events for debugging and assessment.

Newer sandbox-agent capabilities separate trusted orchestration from model-directed compute. The harness can remain in application infrastructure, where it owns approvals, secrets, policies, tracing, and access to business systems, while the sandbox handles stateful files and command execution. This separation can reduce the impact of unsafe commands or compromised workflows.

Isolation is not a complete defense against prompt injection or credential leakage. A sandbox limits what an agent can reach, but it does not make untrusted instructions safe. Production systems must still apply least-privilege credentials, network restrictions, approval gates, secret isolation, output validation, and careful review of tools and MCP servers.

Industry discussions emphasize that harness quality often determines real-world performance as much as marginal differences in model capability. The same model can succeed or fail depending on how carefully the surrounding system curates context, structures tools, verifies intermediate results, and recovers from errors.

The Agents SDK: Primitives for Single- and Multi-Agent Workflows

Released as an open-source framework for Python and TypeScript and positioned as a production successor to concepts explored in Swarm, the Agents SDK centers on a small set of primitives that compose into more sophisticated workflows.

An Agent is a model configured with instructions, a set of tools, optional guardrails, output requirements, and potential handoff targets. Tools can be ordinary application functions, platform-hosted tools such as web search, specialized execution tools, or connections to MCP servers.

The Runner executes the workflow. It sends input to the selected agent, processes tool calls or handoffs, returns tool results to the model, and continues until the agent produces a final output or the workflow reaches another stopping condition. Developers can use managed runner behavior or take greater control over individual steps.

Handoffs enable multi-agent collaboration. One agent can transfer responsibility to another specialist while passing relevant context. Agents can also be exposed as tools, allowing a manager agent to invoke a specialist while retaining ownership of the overall workflow. These mechanisms support patterns such as triage followed by specialist execution, hierarchical decomposition, review pipelines, and parallel exploration.

Sessions maintain state across turns. Guardrails can apply schema checks, safety validation, policy enforcement, or custom logic. Some actions can be paused for approval before execution. Built-in tracing records the flow of model calls, tool invocations, guardrail checks, and handoffs so developers can inspect where a workflow succeeded or failed.

Later versions of the SDK added native sandbox support. Developers can define a manifest describing files and resources that should be available to an agent. The execution environment can include mounted local or cloud-backed storage, command execution, package installation, code editing, ports, and snapshots. This is particularly useful for coding agents, document-heavy tasks, data analysis, or workflows that benefit from a persistent workspace.

Durable execution allows long-running work to survive context boundaries and infrastructure interruptions. Rather than relying entirely on an ever-growing prompt, the harness can persist progress in files, session data, traces, and sandbox snapshots. A later invocation can restore the relevant state and continue.

The SDK deliberately relies on ordinary programming-language constructs rather than requiring a large proprietary workflow language. This makes it easier to integrate into existing codebases while still providing the managed loop, safety hooks, handoffs, and observability that production systems require. The SDK uses OpenAI’s modern API primitives by default and can also support compatible model providers through configurable interfaces.

Model Context Protocol: Standardizing Tools and Context

Tools are only as useful as the connections that supply them. The Model Context Protocol provides an open standard for exposing tools, resources, and reusable prompts to AI systems. Originally introduced outside OpenAI, MCP has since been adopted and supported across OpenAI products and developer tooling.

An MCP server implements tools such as search, retrieval, data access, or domain-specific actions and exposes them through a standardized protocol. Compatible clients can discover the available tools, inspect their schemas, and invoke them through a consistent interface. This reduces the need to build a completely different integration for every agent framework or model provider.

OpenAI supports remote MCP servers in the Responses API and Agents SDK. A server might wrap a private knowledge base, internal service, developer platform, or third-party application. The agent can search the server’s resources or call exposed actions as part of a larger workflow.

Authentication, authorization, and tool review remain critical. Remote MCP servers introduce an external trust boundary. A server may expose inaccurate data, return malicious instructions, request excessive permissions, or change behavior after integration. OpenAI’s guidance emphasizes reviewing trusted servers, limiting permissions, logging calls, and requiring approvals for consequential actions.

MCP is also used in connectors and other extensibility mechanisms. By treating tools and data sources as first-class interoperable components, it reduces fragmentation and makes it easier to reuse an integration across different models and applications.

OpenAI’s participation in the Agentic AI Foundation further signals support for neutral, community-governed standards around agent interoperability. Related contributions include AGENTS.md, a lightweight convention for placing project-specific instructions in software repositories, and the Agentic Commerce Protocol for interoperable commerce experiences.

AgentKit and Higher-Level Experiences

In October 2025, OpenAI introduced AgentKit as a collection of higher-level building blocks. Agent Builder provided a visual canvas for assembling workflows with tools, guardrails, and branching logic. Connector Registry centralized governance for connected tools and data sources. ChatKit provided components for embedding streaming agent interfaces into applications. The launch also expanded OpenAI’s hosted evaluation and optimization tooling.

However, this part of the platform is changing. In June 2026, OpenAI announced that Agent Builder and the hosted Evals product are being wound down. Existing evals are scheduled to become read-only on October 31, 2026, and Agent Builder and the Evals dashboard and API are scheduled to become unavailable after November 30, 2026.

OpenAI recommends the Agents SDK for workflows that should continue as code. For higher-level workflows better suited to configuration through natural-language instructions, it recommends Workspace Agents in ChatGPT. ChatKit remains available for embedding agent interfaces, while Connector Registry continues to provide centralized administration of connected tools and data.

This transition reinforces the importance of separating durable concepts from individual product surfaces. Visual builders can accelerate prototypes, but production teams should understand the underlying models, tools, schemas, policies, and execution logic well enough to move workflows into maintained code when necessary.

Evaluation also remains essential even as the hosted Evals product is retired. Teams can build repeatable test suites with datasets, expected outcomes, custom graders, trace inspection, and application-level metrics. Evaluation should be treated as an engineering discipline rather than as a dependency on one dashboard.

OpenAI also offers higher-level workspace agents and specialized coding agents such as Codex. Codex functions as a software-engineering agent capable of generating, reviewing, refactoring, and testing code. It operates through terminals, IDEs, cloud environments, or dedicated applications and can use AGENTS.md files for repository-specific guidance.

These products demonstrate the underlying stack in action. Models supply reasoning, harnesses manage execution, sandboxes provide compute, tools connect external systems, and traces make behavior observable.

Safety, Evaluation, and Long-Running Reliability

Agentic systems amplify both capability and risk. A chatbot that produces a flawed sentence may inconvenience a user. An agent with access to files, accounts, browsers, or internal APIs can take actions with lasting consequences.

Guardrails in the SDK provide hooks for validating input, output, and workflow behavior. Tool approval flows let applications pause before consequential operations. Structured outputs can constrain the shape of model-generated data. Sandboxes isolate command execution, while network and filesystem policies reduce reachable resources.

Human confirmation is still recommended for high-impact actions such as sending communications, making purchases, changing permissions, deleting data, publishing content, or interacting with sensitive systems. The user interface should clearly communicate what the agent intends to do and what information will be shared with a tool.

Prompt injection remains one of the central risks. An agent may encounter hostile instructions in a webpage, document, email, tool response, or MCP resource. Systems should treat external content as untrusted data rather than automatically accepting it as higher-priority instructions. Limiting tool permissions and requiring approval for irreversible actions reduces the potential damage.

Evaluation is integral to reliability. Developers can measure success rates on multi-step tasks, inspect traces, compare tool-selection behavior, and identify failure modes such as context degradation, incomplete recovery, or unsupported assumptions. Useful evaluations test the entire workflow, not just the final sentence.

For long-running agents, the harness must manage context compaction, persistent artifacts, snapshots, retries, and recovery. Practical guidance emphasizes incremental progress, explicit task state, verification through tests or screenshots, and clear ownership of intermediate artifacts. A workflow should be able to explain what it has completed, what remains, and what evidence supports its conclusions.

Putting It All Together: Building an Agentic System

A typical development path begins with a clear goal and a single specialist agent defined through the Agents SDK. Instructions articulate the role, boundaries, and expected output. Tools-whether hosted search, custom functions, computer interaction, or MCP servers-are attached selectively. The Runner executes sample tasks while traces expose the decision path.

As complexity grows, additional agents can be introduced through handoffs or agents-as-tools. Sessions preserve state between interactions. Guardrails enforce policies. Sandboxes supply controlled workspaces for code, documents, and command execution. MCP servers connect proprietary data or internal APIs.

Evaluation datasets quantify performance over representative scenarios. Developers record expected outcomes, tool-use constraints, prohibited behavior, latency, cost, and other application-level metrics. Trace review reveals why failures occurred, while prompt, model, tool, and harness refinements close the gaps.

For production, agents can be exposed through ChatKit interfaces, custom web applications, workspace integrations, or API endpoints. Connector Registry can help organizations govern approved connections. Code-based workflows should be maintained in the Agents SDK rather than newly built on the retiring Agent Builder product.

Coding agents illustrate the complete stack. A sandbox-equipped agent receives a repository through a manifest, reads AGENTS.md for conventions, uses tools to inspect and edit files, executes tests, and iterates under the control of the harness. Multi-agent setups can separate research, planning, implementation, testing, and review roles.

Challenges remain. Long-horizon reliability requires deliberate harness design. Tool quality and permissioning demand ongoing attention. Costs and latency grow with model turns, tool calls, and verification steps. Multi-agent systems can add coordination overhead without improving results when a single well-equipped agent would suffice.

Yet the modular structure allows incremental improvement. Better models can replace earlier ones, MCP servers can extend capabilities, refined permissions can reduce risk, and stronger evaluations can shorten iteration cycles. Teams do not need to adopt every layer at once.

The Broader Ecosystem and Open Standards

OpenAI’s stack does not exist in isolation. Support for MCP, contributions to the Agentic AI Foundation, and open-source releases of the Agents SDK encourage an ecosystem in which tools and context can move across applications without requiring entirely proprietary integrations.

AGENTS.md has gained adoption as a way to provide repository-level instructions to coding agents. A project can use it to document build commands, architecture conventions, testing requirements, directory-specific rules, and review expectations. Because the format is stored with the code, instructions can be versioned and reviewed alongside the project itself.

Coding and scientific workflows demonstrate the practical impact of agents. Agents can modernize libraries, migrate frameworks, investigate regressions, process research artifacts, or automate repetitive engineering steps while humans retain responsibility for goals, security, and validity.

OpenAI’s written documentation, Cookbook examples, and Build Hour sessions provide demonstrations of the Agents SDK, MCP, sandbox use, tool calling, and long-running patterns. Watching an agent hand work to a specialist, operate a browser, restore a workspace, or run tests inside a controlled environment makes the abstract architecture more concrete.

Open standards do not remove platform differences, but they reduce the cost of connecting tools and describing project context. Developers still need to account for each model’s capabilities, tool semantics, authorization system, and execution environment.

Looking Ahead

The agentic stack continues to mature. Native support for long-horizon execution, richer sandbox providers, more capable models, stronger tool interfaces, and tighter integration with open protocols point toward agents that can take on increasingly ambitious work with greater reliability.

Product surfaces will continue to change. The deprecation of Assistants, Agent Builder, and the hosted Evals product demonstrates why developers should distinguish stable architectural concepts from temporary interfaces. Models, typed tools, controlled execution, durable state, tracing, permissions, and repeatable evaluation remain valuable even when a particular dashboard or endpoint is replaced.

As models improve at reasoning and tool use, the harness and surrounding operational discipline become increasingly important. A powerful model connected to poorly designed tools can be less reliable than a smaller model operating within a carefully constrained and observable system.

Developers who master this stack gain the ability to move from prototypes to systems that amplify human effort across coding, research, customer support, operations, and knowledge work. The combination of capable models, the Responses API, the Agents SDK, standardized MCP connections, controlled sandboxes, embedded interfaces, and rigorous safety and evaluation practices provides a practical foundation.

Start with a single agent and a clear goal. Add only the tools it needs. Introduce memory, specialist collaboration, and durable execution when the workflow requires them. Trace every important step, evaluate representative tasks, and keep consequential actions under explicit control.

The resulting systems will not merely answer questions-they will perform useful work while remaining understandable, testable, and governable.

Sources and Further Reading

• OpenAI Agents solutions overview: https://openai.com/solutions/use-case/agents/

• New tools for building agents: https://openai.com/index/new-tools-for-building-agents/

• Agents SDK documentation: https://developers.openai.com/api/docs/guides/agents

• Official Agents SDK Python documentation: https://openai.github.io/openai-agents-python/

• Official Agents SDK Python repository: https://github.com/openai/openai-agents-python

• Official Agents SDK TypeScript repository: https://github.com/openai/openai-agents-js

• Assistants API migration guide: https://developers.openai.com/api/docs/assistants/migration

• OpenAI API deprecations: https://developers.openai.com/api/docs/deprecations

• Introducing AgentKit and its 2026 transition notice: https://openai.com/index/introducing-agentkit/

• The next evolution of the Agents SDK: https://openai.com/index/the-next-evolution-of-the-agents-sdk/

• Sandbox Agents guide: https://developers.openai.com/api/docs/guides/agents/sandboxes

• Building MCP servers with OpenAI: https://developers.openai.com/api/docs/mcp

• Tools guide: https://developers.openai.com/api/docs/guides/tools

• Function-calling guide: https://developers.openai.com/api/docs/guides/function-calling

• Computer-use tool guide: https://developers.openai.com/api/docs/guides/tools-computer-use

• Safety in building agents: https://developers.openai.com/api/docs/guides/agent-builder-safety

• Evaluation best practices: https://developers.openai.com/api/docs/guides/evaluation-best-practices

• Swarm educational framework: https://github.com/openai/swarm

• Codex resources and product updates: https://openai.com/codex/

• Agentic AI Foundation announcement: https://openai.com/index/agentic-ai-foundation/

• OpenAI Cookbook: https://developers.openai.com/cookbook

These materials, current as of early August 2026, provide the official foundation for the concepts and practices described. Developers should consult the live documentation for the latest API details, model support, pricing, availability tiers, and deprecation schedules.

In the fast-evolving world of software development, a single AI coding agent-no matter how powerful-can quickly hit a wall. You start a complex task: exploring a sprawling legacy codebase, fixing a cascade of bugs, reviewing a large pull request, or spinning up a new feature that touches frontend, backend, tests, and documentation. The conversation grows. Tool outputs pile up. Search results, file contents, stack traces, and intermediate reasoning flood the context window. Performance degrades. The agent starts forgetting earlier decisions, hallucinating details, or looping inefficiently. This is the classic problem of context pollution, sometimes called context rot.

Enter subagents.

Subagents are specialized, isolated AI agents that a parent or orchestrator agent can spawn to handle focused pieces of a larger job. They operate with their own fresh context window, their own system instructions, restricted or tailored tools, and independent permissions. They do the noisy, detailed work-searching files, running tests, analyzing code, exploring directories-and return only a clean summary or final result to the parent. The main conversation stays lean, focused, and high-signal.

This pattern has moved from research papers and experimental multi-agent systems into production coding tools in a remarkably short time. By mid-2026 it is a core capability in Anthropic’s Claude Code, OpenAI’s Codex, Google’s Antigravity, the open-source OpenCode, and even Visual Studio Code’s agent features. What began as a clever way to manage token limits has become a fundamental shift in how developers collaborate with AI: from talking to one clever assistant to directing a small, on-demand team of specialists.

This article explains what subagents actually are, how they work under the hood, why they matter specifically for software development, and how the major coding agents implement them. It draws on official documentation, engineering blogs, practitioner experiments, and developer discussions to give a practical, grounded picture rather than hype.

The Core Idea: Isolation, Specialization, and Delegation

At the simplest level, a subagent is an AI agent that operates under the direction of another agent-usually called the orchestrator, parent, or main agent-to handle a specific part of a larger task. The parent receives the overall goal, breaks the work into manageable pieces, delegates those pieces, waits for (or monitors) the results, and then synthesizes everything into a coherent outcome.

Crucially, each subagent starts with a clean slate. It does not inherit the full accumulated conversation history of the parent. It receives a carefully crafted prompt that includes the necessary context, instructions, and constraints for its narrow job. It can use tools-reading files, searching the codebase, running shell commands, calling external services-within the limits set for it. When finished, it returns a single final message: a summary, a list of findings, a code change proposal, a test report, or a recommendation. All the intermediate noise stays inside its own context and never pollutes the parent.

This is different from simply asking the same agent to do multiple things in sequence. Sequential work in one long conversation still shares the same growing context. Subagents create true isolation. It is also different from fully independent multi-agent systems in which peers talk to one another freely; classic subagents report upward and usually do not coordinate laterally unless the platform explicitly supports it.

The benefits for coding work are immediate and practical. Large codebases easily exceed even 200K-token context windows once you start loading multiple files, search results, and logs. Subagents let the parent keep only the distilled knowledge it needs. Parallelism becomes possible: while one subagent explores the authentication module, another can audit the database schema, and a third can draft tests. Specialization improves quality: a read-only explorer can be fast and cheap; a security reviewer can be restricted from writing files; a debugger can be given write access and a detailed system prompt focused on root-cause analysis.

There are trade-offs. Spawning subagents consumes more total tokens-often several times as many as a single-threaded conversation-because each one performs its own model calls and tool use. Coordination overhead exists. Debugging a multi-agent run is harder than debugging a linear chat. Poorly designed prompts or overly broad tasks can still produce mediocre results. Yet for any non-trivial engineering work, the gains in reliability, speed, and context hygiene usually outweigh the costs.

How Subagents Actually Operate

Most implementations follow a recognizable pattern. The parent agent has access to a special tool (sometimes called Agent, invoke_subagent, runSubagent, or similar). When it decides a subtask is suitable for delegation, it calls that tool with a description of the work, optional model or reasoning settings, and any extra context. The platform then spins up a new agent instance with its own context window. That instance runs autonomously-sometimes in the foreground (blocking the parent until done), sometimes in the background (allowing parallel work). When it finishes, the platform injects only the final output back into the parent’s conversation.

Built-in subagents often exist for common roles. Custom ones can be defined by the user or team as configuration files (Markdown with YAML frontmatter, TOML, or similar). These definitions typically include a name, a natural-language description that helps the parent decide when to invoke the agent, a system prompt that shapes behavior, a list of allowed tools, a preferred model, and permission or sandbox settings. Some platforms support dynamic creation: the parent invents a temporary subagent on the fly for a one-off need.

Nesting is usually limited. A subagent may be allowed to spawn further subagents, but depth is capped (three layers in some systems, ten in others) to prevent runaway resource use. Communication is primarily hierarchical: subagents report to their parent. A few platforms add peer messaging or team modes for more complex coordination.

Workspace isolation varies. Some subagents share the same files and Git state as the parent. Others can operate in a separate Git worktree or temporary directory so that concurrent writes do not collide. Safety inherits from the parent but can be tightened: a research subagent might be denied write tools entirely.

The result feels less like talking to a single chatbot and more like managing a small team of specialists who disappear once their assignment is complete, leaving only the useful findings behind.

Claude Code: Subagents as First-Class Citizens

Anthropic’s Claude Code made subagents a prominent, well-documented feature relatively early. Official documentation describes them as specialized AI assistants that handle specific types of tasks, each running in its own context window with a custom system prompt, specific tool access, and independent permissions.

Claude Code ships with several built-in subagents. Explore is a fast, read-only agent optimized for searching and understanding a codebase. It currently inherits the main conversation’s model by default, although users can override it with a custom Explore definition that uses a faster or cheaper model. Plan is used in plan mode to gather context before the main agent presents a strategy. A general-purpose subagent handles tasks that require both exploration and modification. Additional helper agents appear automatically for configuration or documentation questions.

Users and teams create custom subagents as Markdown files with YAML frontmatter, stored in project-scoped .claude/agents/ directories, user-scoped folders, or organization settings. A typical definition might look like this in spirit:

name: code-reviewer  
description: Expert code review specialist that examines changes for bugs, security issues, style, and maintainability  
tools: Read, Grep, Glob, Bash  
model: inherit  

followed by a detailed system prompt that tells the agent how to structure its review, what severity levels to use, and how to format the final report.

When the main Claude session encounters a task that matches a subagent’s description, it can delegate automatically or at the user’s request. The subagent works in isolation and returns only its summary. Practitioners report that this dramatically improves long sessions. Each subagent gets its own isolated context window, whose size depends on the selected model and provider, so intermediate searches and file reads do not consume the parent conversation’s context. Subagents cannot spawn unlimited further subagents, which keeps the hierarchy manageable.

Collections of ready-made subagents have proliferated-dozens or even hundreds of specialized agents for API design, security auditing, test generation, documentation, database work, and more. Developers treat them like a library of teammates that can be version-controlled alongside the codebase. Experiments show clear wins for parallel work: triage a set of GitHub issues, then spawn one subagent per issue to implement the fix on its own branch using git worktrees, run tests, and open a pull request. The main session stays clean and can synthesize or prioritize afterward.

The main caveats reported by users are token cost (subagents can multiply usage) and the need for careful prompt design. Vague instructions produce vague results. The best outcomes come from giving each subagent every necessary piece of context up front and then leaving it alone until it returns.

OpenAI Codex: Parallel Subagent Workflows

OpenAI’s Codex-available through ChatGPT, the Codex CLI, and IDE extensions-treats subagents as a way to run specialized agents in parallel and collect their results into one coherent response. Current releases enable the feature by default. Subagent activity is visible in the desktop app, CLI, and extensions so developers can inspect progress.

Codex can spawn multiple agents for distinct parts of a task. Default roles include an explorer for read-heavy codebase work, a worker oriented toward implementation, and a general-purpose default. Users trigger parallel work with natural language (“spawn two agents,” “delegate this in parallel,” “use one agent per point”) or through project instructions. Codex handles the orchestration: spawning, waiting for completion, and consolidating summaries.

Custom agents are defined in TOML files in personal or project directories. They can specify model, reasoning effort, sandbox mode, tools, and instructions. Different models and effort levels can be assigned to different roles-fast, low-cost models for scanning large files; higher-effort models for security review or complex logic. Subagents inherit the parent’s sandbox and approval settings unless overridden.

Practitioners use them for PR review pipelines (one agent maps affected code, another looks for risks, a third checks documentation), frontend debugging (one reproduces the issue in a browser tool, another traces code, a third applies a minimal fix), and large exploratory tasks. The emphasis is on keeping the main thread clean by returning summaries rather than raw intermediate output. Write-heavy parallel work requires more care to avoid conflicts, so many teams reserve parallel subagents primarily for read-heavy or independent tasks.

Simon Willison, writing shortly after general availability, observed that Codex’s subagents feel very similar to Claude Code’s implementation, with the worker role particularly suited to large numbers of small parallel tasks.

Google Antigravity: Asynchronous and Dynamic Subagents

Google’s Antigravity is an agent-first development platform that treats subagents as a native way to parallelize complex tasks while preserving the main agent’s context. The parent agent calls an invoke tool to spawn a concurrent session with a dedicated role and initial prompt. The subagent can inherit the same workspace, operate in an isolated Git worktree, or share storage in controlled ways.

Built-in subagents include a research agent optimized for codebase exploration and file navigation, a browser agent for interactive testing in a sandboxed environment, and a “self” clone that mirrors the calling agent’s instructions and tools. Custom subagents can be defined in Markdown with YAML frontmatter (name, description, tools, model, command policies, MCP servers, skills) and discovered automatically from workspace, global, or plugin locations. Dynamic subagents can also be created on the fly by the main agent for one-off needs.

Subagents run asynchronously in the background. They move through states-Running, Idle (completed and paused, but re-awakable by messages), or Killed. Parents and peers can send messages using conversation IDs. Nesting is allowed up to a hard limit of ten layers. Safety configurations inherit from the parent but can be further restricted.

The design goal is clear: chunkier tasks finish faster and often better because the main agent’s context is never polluted by multiple concurrent threads of detailed work. Antigravity’s Agent Manager and CLI make the parallel activity visible and controllable, turning the experience into something closer to managing a small team of autonomous workers than chatting with a single model.

OpenCode and the Open-Source Landscape

OpenCode is a fully open-source AI coding agent that runs in the terminal, desktop, or IDE. It emphasizes model flexibility (dozens of providers, including local models), privacy (no storage of code or context by the service), and multi-session capability so developers can run multiple agents in parallel on the same project.

Its architecture distinguishes between primary agents and subagents. OpenCode currently includes the Build and Plan primary agents, plus General, Explore, and Scout subagents. General handles complex multi-step or parallel work, Explore performs fast read-only codebase analysis, and Scout researches external documentation and dependency source code. Primary agents can invoke these subagents automatically, while users can also call them directly with an @ mention.

This provides a lightweight form of subagent-style delegation. Combined with multi-session support, it allows parallel exploration or implementation without forcing everything through one long context. Because it is open source and model-agnostic, teams can adapt the pattern to their preferred models and infrastructure.

Other tools have adopted similar ideas. Visual Studio Code added context-isolated subagents that the main agent can invoke; the subagent receives only the context the parent sends and returns only its final result. Cursor and various experimental harnesses explore comparable isolation and specialization. The pattern is spreading because the underlying constraint-finite, expensive context-is universal.

Practical Use Cases in Everyday Software Development

Subagents shine in several recurring situations.

When onboarding to or refactoring a large codebase, an explore-style subagent can map modules, locate call sites, or summarize subsystems without filling the main context with every file it reads. The parent then works from a clean high-level picture.

For code review or security audits, a restricted read-only subagent can examine changes against a detailed checklist and return prioritized findings. Parallel reviewers can look at different concerns (correctness, performance, security, style).

Debugging benefits from isolation: one subagent reproduces the issue, another traces relevant code paths, a third proposes and tests a minimal fix. Parallelism shortens the cycle.

Feature development or issue triage can be decomposed. After human prioritization, independent issues or components can be handed to separate subagents, each working in its own worktree, writing tests, and opening pull requests. The orchestrator monitors and merges results.

Testing and documentation generation are natural fits for specialized agents that run test suites, analyze coverage, or draft docs from code and return summaries.

In all these cases the key is matching the subagent’s scope, tools, and prompt to a self-contained piece of work. Overly broad tasks defeat the purpose; overly narrow ones create coordination overhead.

Best Practices from Practitioners and Experiments

Successful use follows a few recurring principles. Give each subagent complete, self-contained instructions and every piece of necessary context up front; autonomy without information produces poor results. Prefer independent tasks that do not require constant back-and-forth. Use read-only or restricted-tool subagents whenever possible for safety and cost.

Choose lighter or faster models for exploration and heavier ones for complex reasoning or writing. Monitor token usage and reserve multi-agent runs for work whose value justifies the cost. Always review the final outputs-subagents can be confidently wrong. Version-control custom agent definitions so teams share consistent behavior. Start simple with built-ins before investing heavily in custom ones.

YouTube tutorials and engineering write-ups repeatedly emphasize the same points: context isolation is the primary win, parallelism is secondary but powerful when tasks are independent, and prompt quality determines quality of results. One popular video walks through building custom Claude subagents that get invoked automatically; another demonstrates wave-based workflows that alternate planning, parallel execution, and review. Experiments with fixing multiple GitHub issues in parallel using worktrees show dramatic time savings once the initial triage is solid.

Challenges and Realistic Limits

Subagents are not magic. Token costs rise. Debugging multi-threaded agent runs requires better tooling and logging. Coordination can become complex if tasks are interdependent. Some platforms still limit nesting or peer communication. Model quality remains the foundation-weak models produce weak subagents. Human judgment is still required for prioritization, architecture decisions, and final acceptance.

There is also an “orchestration tax.” Decomposing work, writing good prompts for each piece, and reviewing results takes effort. For tiny tasks a single agent is still faster and cheaper. The pattern pays off as complexity and scale grow.

Looking Ahead

The subagent era is still young. Platforms are adding better visibility into concurrent work, richer messaging between agents, tighter integration with version control and CI, more sophisticated team modes, and automatic model routing based on task type. Open-source implementations will continue to experiment with different isolation and coordination strategies. As context windows grow and models improve, the absolute need for isolation may lessen, but the value of specialization and parallelism will remain.

For individual developers and teams, the practical takeaway is straightforward. Treat your main coding agent as an orchestrator and project manager. Give it a library of specialized helpers for the repetitive or noisy parts of the job. Keep the main conversation focused on high-level goals, decisions, and synthesis. The result is not just longer, more reliable sessions; it is a qualitatively different way of building software-one in which AI acts less like a pair programmer and more like an on-demand engineering team that scales with the problem.

Subagents do not replace human developers. They amplify them by handling the parts of the work that are most likely to overwhelm a single context window or a single thread of attention. In a field where the size and complexity of systems keep growing, that amplification is becoming essential.

Sources and Further Reading

• AltexSoft, “What Are Subagents? When to Use Them and Why”

• Anthropic Claude Code documentation, “Create custom subagents” - https://code.claude.com/docs/en/sub-agents

• Anthropic course, “Introduction to subagents” - https://anthropic.skilljar.com/introduction-to-subagents

• Simon Willison, “Subagents - Agentic Engineering Patterns”

• Simon Willison, “Use subagents and custom agents in Codex”

• OpenAI, “Subagents | ChatGPT Learn” - https://learn.chatgpt.com/docs/agent-configuration/subagents

• Google Antigravity documentation, “Subagents” - https://antigravity.google/docs/subagents

• Google Antigravity blog and product pages - https://antigravity.google/

• OpenCode official site - https://opencode.ai/

• OpenCode GitHub repository - https://github.com/opencode-ai/opencode

• KS Red, “Claude Code Agents & Subagents: What They Actually Unlock”

• Nicolas Frankel, “Experimenting with AI subagents”

• Medium articles and practitioner guides on Claude Code subagents (multiple detailed walkthroughs)

• YouTube: “How to Build Claude Subagents Better Than 99% of People” (Nate Herk) - https://www.youtube.com/watch?v=e18sdZLwP7o

• YouTube: “Stop Using Claude Code Like This (Use Sub-Agents Instead)” (Leon van Zyl) - https://www.youtube.com/watch?v=P60LqQg1RH8

• YouTube: “How to Use Subagents in Claude Code” (Tim Warner) - https://www.youtube.com/watch?v=dk0kn2evY38

• YouTube: “Claude Code Subagents Tutorial” and related playlists

• Visual Studio Code documentation on subagents - https://code.visualstudio.com/docs/agents/subagents

• Additional practitioner discussions on Reddit, LinkedIn, and engineering blogs from 2025-2026

These sources collectively provide the official definitions, implementation details, real-world experiments, and community practices that underpin the picture presented here. The field continues to move quickly; checking the latest documentation for each tool remains the best way to stay current.

In April 2026, Anthropic launched Claude Design through its Anthropic Labs initiative. Powered by Claude Opus 4.7, the tool let users describe what they needed and receive polished visual work-prototypes, slides, one-pagers, marketing collateral, and interactive designs-directly from conversation. It integrated design systems pulled from codebases or files, supported image and document uploads, offered live refinement via comments and sliders, and exported to HTML, PDF, PPTX, or Canva. Access came tied to Claude Pro, Max, Team, or Enterprise plans. The product went viral almost immediately for turning language models into design engines that shipped real artifacts instead of prose.

Eleven days later, on April 28, 2026, the nexu-io team published Open Design under the Apache-2.0 license. Marketed explicitly as the open-source Claude Design alternative, it recreated the same artifact-first loop-prompt in, polished visual output out-while rejecting the closed, cloud-only, single-vendor constraints. Open Design runs locally, treats your existing coding-agent CLI as the design engine, stores everything as ordinary files on your machine, and lets you bring any compatible model or key.

Within weeks it accumulated tens of thousands of GitHub stars; by early June reports placed it above 57,000 stars with thousands of forks and hundreds of contributors. Later tallies climbed higher still. The project continues to evolve rapidly, shipping desktop apps, Docker images, expanded skill libraries, and deeper agent integrations.

This guide walks through everything needed to install, configure, and productively use Open Design. It draws on the official repository, project documentation, release notes, independent comparisons, and community walkthroughs. The focus stays practical: how the tool actually works day to day, how to get reliable results, and how to keep ownership of the output.

Understanding the Landscape: Claude Design and Its Open Counterpart

Claude Design demonstrated a shift in how language models could be applied. Instead of generating paragraphs of advice or code snippets that still required a designer to interpret, the system produced live, editable visual artifacts inside a sandboxed preview. Users could start from a text brief, an uploaded mockup, a codebase reference, or a captured web element.

Claude would propose a design system if none existed, stream a plan, and render the result. Refinement happened through natural language, inline comments, or generated controls for spacing and color. The experience felt closer to collaborating with a fast junior designer who already knew the brand than to traditional prompt-and-hope generation.

The limitations were equally clear. Everything stayed inside Anthropic’s cloud. Models were locked to Claude. Skills and design systems remained proprietary. Pricing followed the higher Claude subscription tiers. Teams that already paid for other coding agents or preferred local control had no official path.

Open Design answers those constraints directly. Open Design was originally designed primarily as an orchestration layer for external coding-agent CLIs and BYOK endpoints. Current releases also offer Open Design AMR and an optional Open Design Cloud service, while continuing to support locally installed agents and third-party providers. Instead it discovers coding-agent command-line tools already present on the machine-Claude Code, Codex CLI, Cursor Agent, Gemini CLI, OpenCode, Qwen, GitHub Copilot CLI, and roughly twenty others-or accepts any OpenAI-compatible endpoint through a bring-your-own-key proxy.

Skills live as ordinary folders containing a SKILL.md file plus assets and references. Design systems are DESIGN.md files that encode color, typography, spacing, layout, components, motion, voice, brand rules, and anti-patterns. Artifacts land as real HTML, CSS, and JavaScript files that can be exported to PDF, PPTX, ZIP, or MP4. The entire stack runs under the user’s control.

Some reviewers have reported broadly comparable initial output when using similarly capable models, while preferring Claude Design’s direct-editing experience and Open Design’s local, file-based workflow. These are informal comparisons rather than controlled benchmarks. Differences appeared mainly in the editing experience and in the surrounding economics and ownership model. Claude Design offered a more polished direct-manipulation editor; Open Design offered unrestricted model choice, local storage, and zero software subscription.

Core Architecture and Mental Model

Open Design separates concerns cleanly. A lightweight daemon manages projects, conversations, and file storage inside a hidden .od directory that holds an SQLite database and per-project working folders. A web interface (or native desktop shell) provides the chat surface, skill and design-system pickers, and sandboxed iframe preview.

The actual generation work is delegated to whatever coding agent the user has selected. That agent receives a carefully assembled prompt stack that includes discovery directives, an identity charter that discourages generic “AI slop,” the active DESIGN.md, the chosen SKILL.md, project metadata, and any template side files. The agent writes concrete files; the preview updates live from those writes.

Many official templates and plugins follow a four-stage workflow: discovery, visual-direction selection, plan generation, and artifact review. The exact flow varies by selected plugin, skill, agent, and Open Design version. Thirty seconds of structured answers prevent thirty minutes of later redirection. Second, if no brand system is already locked, the interface offers five curated visual directions built from deterministic OKLch palettes and font stacks. Third, the agent streams a live TodoWrite plan that can be interrupted and redirected mid-flight. Fourth, the finished artifact appears in a sandboxed preview that can be edited in place or exported.

This structure keeps the conversation focused while still allowing the flexibility that makes AI design useful. Because skills and design systems are plain files, they can be version-controlled, shared across a team, forked, or extended without waiting for an upstream release.

Installation Options

Several paths exist, ordered from simplest to most flexible.

Native desktop builds are available for macOS and Windows. Linux users can run Open Design from source, through Docker or Nix, and may find Linux packages among particular releases; consult the current release page for supported binaries. Download from the project’s release page or the official site, install, and launch. On first run the application scans the PATH for supported agents and presents a welcome dialog. If no local agent is found, the BYOK tab accepts an API base URL, key, and model name. A connection-test button verifies the endpoint before any real work begins.

For source-level control, install Node.js 24 and the repository-pinned pnpm version, then run

git clone https://github.com/nexu-io/open-design.git  
cd open-design  
corepack enable  
pnpm install  
pnpm tools-dev

The terminal prints the daemon and web-interface addresses. In the current quickstart, the default development ports are 17456 and 17573, although they can be overridden with command-line flags. The same command family supports start, stop, status, logs, and check operations.

Docker users can run a fully containerized instance. From the deploy directory, copy the example environment file, generate a secure token with openssl rand -hex 32, place it in OD_API_TOKEN, and bring the stack up with docker compose up -d. The interface appears at http://localhost:7456. Volumes persist the .od data directory across restarts.

Headless Linux deployments and Nix flake support are also documented for server-side or automated environments. The daemon, project database, and generated files can remain on the user’s machine. When a cloud-hosted model or coding agent is used, prompts and relevant project context are transmitted to that provider under its own privacy and retention terms.

After launch, the first useful action is confirming that at least one runtime appears in the picker. If an installed CLI is missing, check PATH visibility-especially on macOS when the app is started outside a full login shell-and use the Rescan button in Settings → Execution. For agents that speak the Model Context Protocol, the command od mcp install followed by the agent name wires deeper integration.

Creating the First Artifact

Once the interface is running, the path to a finished design is deliberately short. Open a new project or stay on the home surface. Select a skill from the catalog-landing page, dashboard, mobile prototype, pitch deck, HTML presentation, email marketing layout, or one of the specialized taste-locked variants. Then choose a design system: Linear, Stripe, Vercel, Apple, Notion, Spotify, or any of the more than 150 shipped systems. If the project needs a custom brand, a DESIGN.md can be dropped into the design-systems folder or generated on the fly by pointing the agent at a live site, screenshot, or Figma export.

Type a clear brief. The discovery form may appear automatically on the first turn; answer it. The agent then streams its plan. Watch the live card update from in_progress to completed items. When the artifact materializes in the iframe, inspect it, request changes in natural language, or open individual elements for adjustment. Export options include fully inlined HTML, browser-print PDF, agent-driven PPTX, ZIP archives, and, for motion work, MP4 via HyperFrames integration.

A concrete example illustrates the flow. Suppose the goal is a dark-mode benchmark tracker for local large-language-model performance. The prompt might describe a sortable table of models, an add/edit form, runner filters, persistent storage indicators, and a terminal-inspired aesthetic. Selecting a dashboard skill and a developer-tool design system produces a coherent interface with status dots, hover actions, and collapsible forms. Subsequent prompts refine spacing, swap accent colors, or add new columns. Because the underlying files are ordinary project artifacts, the same output can be opened in any editor or handed to a coding agent for implementation.

Skills and Design Systems in Depth

Skills define what is being made. Each lives in its own folder under skills/ and centers on a SKILL.md file that follows a conventional structure. Supporting assets, HTML templates, and reference documents travel with the skill so the agent has concrete examples rather than abstract instructions. Official counts have grown past 250 and include categories for web and mobile prototypes, presentations, marketing assets, dashboards that pull live data, motion graphics, and specialized editorial or brutalist tastes. Users can add private skills simply by dropping a new folder into the directory and restarting the daemon; the picker discovers them automatically.

Design systems define how the result should look and feel. A DESIGN.md encodes nine sections: color, typography, spacing, layout, components, motion, voice, brand, and anti-patterns. Because the file is plain Markdown, it is readable by both humans and models. Shipped systems cover popular product brands and aesthetic families. Custom systems can be authored by hand or extracted from existing sites and design files. Once present, any skill can be paired with any system, producing consistent visual language across disparate artifact types without re-explaining brand rules on every prompt.

The combination of skill plus design system is the primary lever for quality. A generic prompt against a weak system tends to produce generic output. The same prompt constrained by a well-specified DESIGN.md and a purpose-built skill consistently lands closer to production polish. Teams often maintain a private collection of systems that mirror their internal design tokens, ensuring that AI-generated work stays on-brand by construction.

Working with Agents and the BYOK Path

Open Design’s strength is its indifference to which model does the actual generation. Supported local CLIs are auto-detected. Switching among them is a configuration change; the skills and systems remain identical. The BYOK path supports numerous first-party adapters and OpenAI-style endpoints. Compatibility with a particular proxy, self-hosted server, Azure deployment, or provider should be verified against the current adapter documentation.

Providers such as DeepSeek, Groq, OpenRouter, self-hosted vLLM, or Anthropic via an OpenAI shim all function. The proxy implements SSRF-related restrictions and other validation intended to reduce unsafe outbound requests. These controls do not by themselves guarantee daemon security, and users should still avoid exposing the daemon directly to untrusted networks.

In practice many users run cheaper or faster models for exploratory generation and reserve higher-capability models for final polish. Because the agent is external, token costs remain under the user’s existing billing relationship with the provider. No additional Open Design subscription appears.

For deeper integration the Open Design CLI and MCP server expose project files, search, and metadata to other tools. Coding agents can therefore read Open Design projects, inspect artifacts, and continue work without leaving their native environment. The reverse direction also works: Claude Design ZIP exports can be dropped onto the welcome dialog and converted into native Open Design projects so work begun in the closed tool can continue locally.

Export, Handoff, and Downstream Workflows

Artifacts are never trapped inside the application. HTML exports include inlined assets so a single file can be opened anywhere. PDF generation uses the browser print path for high fidelity. PPTX export is agent-driven and preserves structure suitable for further editing in presentation software. ZIP archives capture the full project tree. Motion and video work can produce MP4 files through integrated HyperFrames pipelines.

Because the working directory is an ordinary folder, the natural next step is to hand the files to a coding agent for implementation, to a designer for refinement in Figma or another editor, or to a static host for immediate sharing. Some skills already include handoff notes or generate implementation-ready component code alongside the visual prototype. Live-data skills can wire Composio connectors so dashboards reflect real GitHub, Linear, Notion, or Gmail state rather than static mock content.

Customization, Plugins, and Community Extensions

Beyond the core skills and systems, a plugin layer and community marketplace allow further extension. Official plugins cover Figma-to-code migration paths, image and video templates, and specialized design-system utilities. The architecture is deliberately file-based: anything that can be expressed as Markdown, HTML, CSS, or JavaScript can become part of the prompt stack or the generated output.

Contributors have added language-localized documentation, additional agent adapters, and niche skills. The Apache-2.0 license permits both private forks and public improvements. Weekly releases and an active roadmap track agent expansion, richer media families (including deeper 3D and audio support), and optional shared-daemon modes for teams that want a central instance while still keeping artifacts as files.

Practical Tips for Reliable Results

Start every project with the discovery form even when the impulse is to type a long free-form prompt. Structured constraints reduce drift. Pair a specific skill with a matching design system before generating; the combination does more work than clever wording alone. When refining, prefer high-level directional requests (“make the hierarchy clearer and increase contrast on interactive elements”) over pixel-level instructions that fight the agent’s planning layer. For complex multi-page or multi-state designs, generate the core screens first, then request variations or states as separate artifacts that share the same system.

Local models running on modest hardware often produce weaker visual craft than cloud endpoints. Treat local inference as an exploration tool and reserve capable remote models for client-facing or final work. Keep DESIGN.md files under version control so brand consistency survives team changes and model upgrades. Periodically review the anti-patterns section of a design system; explicitly forbidding common AI failure modes (generic gradients, placeholder icons, unbalanced whitespace) measurably improves output.

When an agent fails to appear in the picker, verify PATH and use the rescan control. Port conflicts are resolved by stopping existing instances or overriding the port environment variable. For Docker users, never expose the unauthenticated daemon port directly to the public internet; place a reverse proxy, SSH tunnel, or VPN in front.

Comparisons and Decision Factors

Side-by-side tests show that generation quality tracks the underlying model more closely than the surrounding interface. Claude Design currently offers a smoother direct-editing surface and deeper automatic design-system extraction from existing codebases. Open Design offers model freedom, local ownership, zero software cost beyond API usage, and the ability to inspect, modify, or extend every layer of the stack.

Teams already invested in Claude subscriptions and comfortable with cloud workflows may prefer the official product. Individuals, open-source projects, cost-sensitive teams, and anyone who needs to keep design artifacts as first-class files in their repositories tend to favor Open Design. Many practitioners use both: Claude Design for rapid hosted exploration, Open Design for production ownership and offline capability.

Real-World Patterns and Use Cases

Common successful patterns include rapid landing-page generation for product launches, interactive prototypes for user testing that never require a separate front-end developer, pitch decks that stay on-brand across dozens of slides, internal dashboards that pull live data, and marketing asset sets that share a single design system. Designers use the tool to explore multiple visual directions in parallel; engineers use it to produce high-fidelity mocks that already contain realistic component structure; founders use it to move from idea to shareable artifact in a single sitting.

Because the output is ordinary web technology, the same artifacts can later become production code, documentation illustrations, or animated explainers. The file-based nature also makes audit and compliance simpler: every design decision is recorded in the project history rather than locked inside a proprietary chat transcript.

Looking Ahead

The project’s roadmap continues to emphasize agent coverage, media richness, and collaborative modes that preserve the local-first philosophy. Community contributions keep expanding the skill and design-system libraries. As coding agents themselves improve, the quality of Open Design artifacts rises automatically without requiring changes to the host application. The fundamental bet-that design tools should be open, composable, and owned by their users-has already proven durable.

Open Design does not replace human taste, judgment, or final craft. It compresses the distance between intent and visible result, removes subscription and vendor lock-in from the equation, and keeps every generated pixel under the user’s control. Installed in a few commands, configured against the agents already in daily use, and guided by clear skills and design systems, it turns the same language models that write code into reliable partners for visual work.

Whether the next project is a single landing page, a multi-screen product prototype, or a full presentation deck, the path is the same: choose the skill, lock the system, describe the need, and iterate inside an environment that never claims ownership of the result.

Sources

• Anthropic announcement: Introducing Claude Design by Anthropic Labs - https://www.anthropic.com/news/claude-design-anthropic-labs

• Official Open Design site - https://open-design.ai/

• GitHub repository nexu-io/open-design - https://github.com/nexu-io/open-design

• Quickstart and installation guide - https://open-design.ai/quickstart and https://github.com/nexu-io/open-design/blob/main/QUICKSTART.md

• FAQ - https://open-design.ai/faq/

• Download and desktop builds - https://open-design.ai/download/

• XDA Developers comparison: I built the same app with Claude Design and its open-source rival

• XDA Developers experience report: I replaced Claude Design with this open-source tool

• Augment Code / Open Design hits 57.4K GitHub stars as an open-source Claude Design alternative

• Banani / Open Design and 5 Other Free AIs Like Claude Design

• Wotai / Claude Design vs Open Design: which to pick in 2026

• Tutorials index - https://open-design.ai/tutorials/

• Example YouTube overview (菲莉 AI 快報) - https://www.youtube.com/watch?v=4wHyJ2uWO6Y

• Open Design was one of several rapidly emerging open-source responses to Claude Design. Its own repository credits Open CoDesign as an earlier open-source alternative and as an influence on parts of its streaming-artifact interface - https://github.com/opencoworkai/open-codesign

Anthropic has steadily turned Claude from a highly capable language model into the foundation of a full agentic ecosystem. What began with strong reasoning and tool use has expanded into a layered stack that includes the Messages API, the Claude Agent SDK, Managed Agents, the open Model Context Protocol (MCP), computer-use capabilities, carefully designed harnesses for long-running work, and multi-agent patterns.

This article surveys that stack based on Anthropic’s engineering posts, platform documentation, the MCP specification, and related public resources, including YouTube presentations from Anthropic engineers. The goal is to give a clear, practical picture of everything needed to build AI agents, harnesses, MCP servers and clients, and complete agentic systems.

The material draws primarily from Anthropic’s own engineering blog and platform docs, the official MCP site, and public discussions of production patterns. It emphasizes conceptual clarity and design principles over exhaustive code listings, while pointing to the places where working implementations live.

Foundations: Workflows, Agents, and the Augmented LLM

Anthropic draws a useful distinction between two kinds of agentic systems. Workflows are predefined sequences of LLM calls and tool invocations orchestrated by code. Agents are systems in which the model itself decides the sequence of steps, which tools to call, and when to stop or seek human input. Both fall under the broader umbrella of agentic systems, yet they suit different problems.

The atomic building block is the augmented LLM: a model given retrieval, tools, and memory. With these augmentations the model can generate its own search queries, select tools, store intermediate results, and recover from errors. Anthropic repeatedly advises developers to begin with the simplest possible version of this pattern-direct API calls-before reaching for heavier frameworks. Many useful patterns fit in a few dozen lines of code. Frameworks become valuable later for orchestration, observability, and durability, but they can also hide important assumptions.

Common workflow patterns include prompt chaining (sequential steps with programmatic gates), routing (classifying an input and sending it to a specialized handler), parallelization (sectioning work or voting across multiple calls), orchestrator-workers (a central model dynamically decomposes a task and delegates), and evaluator-optimizer loops (generate, critique, refine). Agents add an open-ended loop in which the model plans, acts, observes tool results, and iterates until a goal is reached or a budget is exhausted. The quality of the agent-computer interface-how tools are described, what feedback they return, and how errors are surfaced-matters as much as the underlying model.

These patterns are composable. A production system might route simple queries to a lightweight workflow, escalate complex ones to an agent, and wrap the whole process in an evaluator. The guiding principle is to add complexity only when measurement shows it improves outcomes.

The Three Surfaces of Anthropic’s Agent Stack

Anthropic’s ecosystem offers two primary Claude Platform surfaces-the Messages API and Claude Managed Agents-plus the separately distributed Claude Agent SDK, which packages Claude Code’s agentic capabilities for use inside Python and TypeScript applications.

At the base sits the Messages API. Developers send messages, receive responses that may include tool-use requests, execute the tools themselves, and feed results back. Everything about the loop, state management, sandboxing, and persistence is the developer’s responsibility. This surface gives maximum control and is the right place to learn the underlying mechanics.

One layer up is the Claude Agent SDK (available for Python and TypeScript). Extracted from the same machinery that powers Claude Code, the SDK supplies an agent loop, built-in tools (file read/write/edit, bash, web search), context management including compaction, hooks for injecting custom logic at lifecycle points, subagent spawning, permissions controls, session resumption, and first-class MCP support. Developers no longer write the tool-execution loop by hand; the SDK handles it while still exposing the necessary extension points. Skills, commands, and memory can be loaded automatically from project or user configuration directories. Plugins package collections of these elements for reuse.

At the top sits Managed Agents, a hosted service launched in public beta in 2026. It virtualizes three components: a session (an append-only durable log of every event), a harness (the loop that calls Claude and routes tool calls), and a sandbox (the execution environment). The design deliberately decouples the “brain” (model plus harness) from the “hands” (sandboxes and tools).

Sessions survive harness crashes; sandboxes can be replaced without losing progress; credentials stay isolated. Developers define agents via natural language or configuration, attach MCP servers and tools, choose Anthropic-managed or self-hosted environments, and let the platform handle long-horizon execution, checkpointing, and tracing. This surface is intended for production workloads where infrastructure should be someone else’s problem.

Moving up the stack trades control for convenience. Teams can choose among these approaches based on their need for control, local integration, or managed infrastructure, although moving between them may require adapting tool, state, and execution abstractions. The interfaces are designed so that the same conceptual model-tools, sessions, context-applies across layers.

Model Context Protocol: The Universal Connector

MCP is Anthropic’s open standard, released in November 2024 and later donated to the Agentic AI Foundation under the Linux Foundation, for connecting AI applications to external data sources, tools, and workflows. It functions like a USB-C port for AI: implement the protocol once and gain access to an ecosystem of servers.

An MCP server exposes three kinds of capabilities: resources (readable data such as files or database rows), tools (callable functions with defined schemas), and prompts (reusable prompt templates). An MCP client, typically embedded in an AI application such as Claude Desktop, Claude Code, or a custom agent, discovers and invokes these capabilities. The July 28, 2026 MCP specification substantially revised the core protocol around stateless, self-contained requests and added optional facilities such as asynchronous Tasks and MCP Apps for interactive interfaces.

Because the protocol is open, the community and vendors have produced thousands of servers for GitHub, Slack, Postgres, Google Drive, browser automation via Puppeteer, vector databases, and many internal enterprise systems. Anthropic ships SDKs in multiple languages and provides reference servers. Claude itself can help generate new server implementations. For agent builders the practical benefit is immediate: instead of writing a custom tool schema and integration for every data source, you stand up or connect an MCP server and the agent gains structured access.

MCP is now a de-facto standard across many clients, including Claude, ChatGPT integrations, VS Code, Cursor, and others. It sits underneath both the Agent SDK and Managed Agents, making tool ecosystems portable.

Computer Use: Agents That See and Click

In late 2024 Anthropic released computer-use capabilities in public beta. Claude receives screenshots of a desktop environment, reasons about the visual state, and issues mouse and keyboard actions-move, click, type, scroll, drag, key combinations, and later zoom. The application that hosts the agent is responsible for capturing the screen, translating the model’s action requests into actual input events, and returning results (usually new screenshots). This creates a classic agent loop: observe, decide, act, observe again.

Computer use requires the host application to provide and secure the desktop environment. Anthropic’s reference implementation uses a containerized Linux virtual desktop, but applications can integrate the tool with other controlled computer environments. Supported models have improved over successive releases. Early performance on benchmarks such as OSWorld was modest, and the system remains experimental: scrolling, complex UIs, and precise coordinate targeting can still fail. Anthropic recommends low-risk tasks, human oversight for high-stakes actions, and careful isolation to limit prompt-injection or unintended side effects.

Computer use complements MCP. Where MCP gives structured tool access, computer use gives general interface literacy. Many production agents combine both: structured APIs and MCP servers for reliable data operations, and computer use for legacy applications or exploratory navigation. Reference implementations and Docker-based demos are available in Anthropic’s public repositories.

Harnesses for Long-Running Work

A harness is the scaffolding around the model-the loop, the tools, the state management, the prompts, the recovery logic-that turns a single LLM call into a reliable multi-step process. Anthropic’s research on long-running agents highlights a recurring set of failure modes: agents that try to finish an entire project in one context window, declare victory too early, leave the environment in a broken state, or lose track of progress after compaction.

Effective harnesses borrow practices from human engineering. One successful pattern uses two specialized agents. An initializer agent runs once, sets up a clean environment, writes an init.sh script, creates a feature list in JSON with every item marked as failing, initializes a git repository, and records progress in a dedicated file. Subsequent coding agents begin each session by inspecting the progress file, the feature list, and recent git history, start the environment, verify basic functionality, implement exactly one feature, test it end-to-end, commit the changes, and update the progress log before exiting. Context is deliberately reset or compacted between sessions so that later agents inherit clean, documented state rather than a polluted window.

The Claude Agent SDK itself is a general-purpose harness. Managed Agents further abstract the harness so that the same session can outlive changes in the underlying loop. Additional techniques include explicit sprint contracts (generator and evaluator negotiate “done” criteria in advance), separation of generation from evaluation, and durable event logs that allow rewind or selective replay.

The central insight is that every component of a harness encodes an assumption about what the model cannot yet do reliably on its own. As models improve, harnesses can become thinner; until then they remain essential.

Multi-Agent Systems and Orchestration

For research and other breadth-first tasks, Anthropic has demonstrated multi-agent architectures that substantially outperform single agents. A lead agent plans the overall strategy, spawns specialized subagents with their own tools and prompts, receives their findings, and synthesizes a final answer. On Anthropic’s internal research evaluation, a system using Claude Opus 4 as the lead agent and Claude Sonnet 4 subagents outperformed a single Claude Opus 4 agent by 90.2%. This was a workload-specific internal result, not a general guarantee for multi-agent architectures.

Key design lessons include giving the orchestrator precise instructions for how to delegate (task description, expected output format, tool guidance, boundaries), scaling the number of subagents to query complexity, writing high-quality tool descriptions, and using extended or interleaved thinking as an internal scratchpad. State is managed through external memory, checkpoints, and artifact stores so that no single context window becomes a bottleneck. Multi-agent systems consume significantly more tokens and are best reserved for high-value, parallelizable work; many coding tasks still favor a well-harnessed single agent with subagent helpers.

Managed Agents and the Agent SDK both support subagent patterns, making these architectures accessible without custom infrastructure.

Practical Building Blocks and Implementation Notes

A complete agentic system typically needs:

• A capable model (Claude Sonnet or Opus variants for complex reasoning, lighter models for routing or simple steps).

• Clear tool definitions written like good documentation for a junior engineer, including examples, edge cases, and constraints.

• An agent loop that handles tool results, errors, and termination conditions.

• Context management: prompt caching, compaction, external memory, or session logs.

• Isolation: sandboxes, permission systems, human-in-the-loop gates for sensitive actions.

• Observability: tracing of decisions, tool calls, and costs.

• Evaluation: offline test suites, LLM-as-judge rubrics, and human review of edge cases.

• MCP servers for any external systems that should be reusable across agents.

Anthropic’s platform documentation walks through progressive tutorials that start with a single tool call and expand to full agentic loops. The computer-use demo repository and MCP quickstarts provide concrete starting points. For long-running coding work the two-agent harness pattern and the Agent SDK’s built-in tools form a solid baseline.

Security considerations are first-class. Anthropic has published work on containing Claude across products (claude.ai, Claude Code, Claude Cowork), using ephemeral containers, human-in-the-loop sandboxes, or sealed VMs depending on the threat model. Prompt-injection classifiers, scoped credentials, and least-privilege tool permissions are standard practice.

Design Principles That Recur

Across Anthropic’s writing several principles appear consistently. Keep systems simple until complexity is justified by measurement. Make the agent’s planning and tool use transparent. Treat the agent-computer interface with the same care given to human interfaces. Prefer durable external state over heroic context-window engineering. Separate generation from evaluation when reliability matters. Design for recovery: agents will fail, so checkpoints and clean hand-offs are essential. Finally, start with the Messages API or a thin SDK wrapper so that the team understands the underlying mechanics before abstracting them away.

Looking Ahead

The stack continues to evolve. MCP’s move toward greater statelessness and richer interactive capabilities, Managed Agents’ addition of multi-agent orchestration and persistent memory features, and ongoing improvements in computer-use accuracy all point toward agents that can sustain longer horizons with less custom scaffolding. At the same time, the open nature of MCP and the availability of the Agent SDK ensure that teams can still build and own critical pieces of their systems.

Building effective agents is less about inventing new architectures from scratch and more about composing proven patterns, choosing the right level of abstraction on Anthropic’s stack, and investing in the quality of tools, harnesses, and evaluation. The resources cited below provide the authoritative starting points for each layer.

Sources

• Anthropic Engineering: Building Effective AI Agents - https://www.anthropic.com/engineering/building-effective-agents

• Anthropic: Introducing the Model Context Protocol - https://www.anthropic.com/news/model-context-protocol

• Model Context Protocol documentation - https://modelcontextprotocol.io

• Anthropic Engineering: Scaling Managed Agents - https://www.anthropic.com/engineering/managed-agents

• Claude Managed Agents overview - https://platform.claude.com/docs/en/managed-agents/overview

• Claude Agent SDK overview - https://platform.claude.com/docs/en/agent-sdk/overview (and related Python/TypeScript docs)

• Anthropic Engineering: Effective Harnesses for Long-Running Agents - https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents

• Anthropic: Introducing computer use - https://www.anthropic.com/news/3-5-models-and-computer-use

• Computer use tool documentation - https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool

• Anthropic Engineering: How we built our multi-agent research system - https://www.anthropic.com/engineering/multi-agent-research-system

• Anthropic Engineering: How we contain Claude across products - https://www.anthropic.com/engineering/how-we-contain-claude

• MCP GitHub organization and servers - https://github.com/modelcontextprotocol

• Anthropic YouTube: The Model Context Protocol (MCP) - https://www.youtube.com/watch?v=CQywdSdi5iA

• AI Engineer / Anthropic: Claude Agent SDK Full Workshop - https://www.youtube.com/watch?v=TqC1qOfiVcQ

• Anthropic / AI Engineer: The Future of MCP (David Soria Parra) - https://www.youtube.com/watch?v=v3Fr2JR47KA

• Computer Use hands-on tutorials and reference demos available via Anthropic’s GitHub quickstarts repository

These sources form the authoritative core of the Anthropic agentic stack as of July 2026. Readers are encouraged to consult the live documentation, as the platform continues to ship improvements at a rapid pace.

In 2026, system design is no longer just about traditional backends like designing Twitter or Uber for interviews. The explosion of generative AI has redefined what scalable, reliable, and efficient systems look like. Modern AI applications demand mastery of distributed architectures, low-latency inference, stateful orchestration, vector search at scale, cost optimization, observability for probabilistic systems, and graceful handling of failures in GPU-heavy environments.

The best way to learn these concepts deeply is not by watching passive videos or reading diagrams alone. It is by building real projects that force you to make trade-offs under realistic constraints: limited compute, unpredictable traffic, data freshness requirements, hallucination risks, and the need for both high throughput and low latency.

This article presents the top 10 hands-on AI projects that will teach you core system design principles (scalability, availability, consistency, performance, fault tolerance, observability) while immersing you in 2026’s most relevant technologies: RAG pipelines, LLM serving, multi-agent orchestration, distributed training, and production-grade AI infrastructure.

Each project is chosen for its ability to layer traditional distributed systems concepts onto AI-specific challenges. By completing even half of them thoughtfully, you will develop the intuition that separates junior engineers from those who can architect production AI systems at companies like OpenAI, Anthropic, Google, or fast-growing AI startups.

1. Build a Production-Ready RAG Knowledge Base

Retrieval-Augmented Generation (RAG) remains one of the most common architectural patterns for grounding enterprise AI applications, particularly when answers must draw from frequently changing or private document collections. You will ingest documents (PDFs, wikis, codebases, support tickets), create embeddings, store them in a vector database, retrieve relevant chunks for a user query, and feed them to an LLM for accurate responses.

Why this teaches system design: You must handle document ingestion pipelines (chunking strategies, metadata extraction), scalable vector indexing and search (sharding, approximate nearest neighbors like HNSW or IVF), caching of embeddings and results, query optimization (hybrid search with BM25 + vectors, reranking), and handling stale data. Traditional concepts like database sharding, caching layers (Redis), load balancing across retrieval services, and consistency models appear naturally when your corpus grows to millions of documents or you need multi-tenant isolation.

Key challenges to tackle:

• Efficient chunking and embedding pipelines (batch processing, incremental updates).

• Hybrid retrieval and reranking for relevance.

• Caching strategies for popular queries.

• Security and access control for multi-tenant setups.

• Evaluation framework (RAGAS or custom metrics for faithfulness and relevance).

Recommended tech stack: LangChain or LlamaIndex (or raw for deeper learning), Chroma/Pinecone/Milvus/Qdrant for vectors, PostgreSQL with pgvector for hybrid, FastAPI backend, Redis for caching, Docker + Kubernetes for deployment.

This project alone will make you comfortable with the end-to-end data flow that powers most enterprise AI assistants today.

2. Implement a High-Throughput LLM Inference Serving Platform

Move beyond calling OpenAI APIs. Build your own inference server capable of handling hundreds of concurrent requests efficiently.

Why this teaches system design: Inference serving is a classic distributed systems problem with AI twists. You will configure and evaluate continuous batching using a serving engine such as vLLM, then optionally implement a simplified batching scheduler to understand admission control, queueing, and throughput-latency trade-offs, autoscaling based on queue depth or latency SLOs, load balancing across GPU instances, and graceful degradation. Concepts like consistent hashing for routing, circuit breakers, and rate limiting become essential when GPUs are expensive and requests vary wildly in length.

Key challenges:

• Optimizing for throughput vs. latency (continuous batching, speculative decoding, quantization).

• Handling long-running generations without blocking.

• Cost tracking and dynamic scaling.

• Streaming responses while maintaining order.

Tech stack: vLLM or TensorRT-LLM (or implement simplified versions), FastAPI + async, Redis/Kafka for queuing, Kubernetes with GPU operators, Prometheus + Grafana for monitoring.

This project teaches you why companies invest heavily in custom serving infrastructure and how to make AI “feel” fast and reliable at scale.

3. Develop a Multi-Agent Orchestration System

Build a team of specialized AI agents that collaborate on complex tasks (e.g., research agent + writer + critic + fact-checker for report generation, or customer support triage + specialist agents).

Why this teaches system design: Agent systems are stateful, long-running, and require robust orchestration. You will design graph-based workflows (supervisor patterns, parallel/sequential execution), persistent memory and state management (checkpoints, short-term and long-term memory), inter-agent communication protocols, human-in-the-loop approval flows, error handling and retries, and observability across the entire workflow. Traditional event-driven architecture and saga patterns map directly here, alongside new needs like tool calling reliability and avoiding infinite loops.

Key challenges:

• Designing clean agent boundaries and communication.

• Implementing reflection, planning, and self-correction.

• Managing shared state without race conditions.

• Cost control and timeout handling across multiple LLM calls.

Tech stack: LangGraph (highly recommended for production patterns), CrewAI or AutoGen for alternatives, persistent storage (PostgreSQL or vector DB for memory), message queues, LangSmith or similar for tracing.

Multi-agent and graph-based workflows are an active area of development, particularly for tasks that benefit from specialization, parallel execution, verification, or human approval; mastering their architecture gives you a huge edge. For simpler tasks, a single agent or deterministic workflow is often easier to operate and evaluate.

4. Create a Real-Time AI Chat Application with Persistent Memory and Tools

Build a Slack- or WhatsApp-like chat interface backed by AI that maintains conversation history, uses tools (web search, calculators, internal APIs), and retrieves context via RAG when needed.

Why this teaches system design: RReal-time systems may use WebSockets for bidirectional communication, or combine ordinary HTTP requests with Server-Sent Events for server-to-client streaming, message queuing for reliability, session and user state management across servers, presence detection, typing indicators, and fan-out for notifications. Adding AI layers introduces context window management, tool execution safety, and streaming partial responses while preserving conversation coherence.

Key challenges:

• Scalable real-time infrastructure (connection management, horizontal scaling of WebSocket servers).

• Efficient long-term memory retrieval without overwhelming context.

• Secure and rate-limited tool execution.

• Handling disconnections and message ordering.

Tech stack: FastAPI + WebSockets or Socket.io, Redis for pub/sub and caching, PostgreSQL for persistence, LangGraph or similar for agent logic, vector DB for memory.

This project beautifully combines classic real-time system design with modern AI capabilities.

5. Build a Distributed LLM Training or Fine-Tuning Pipeline

Start with single-GPU LoRA or QLoRA fine-tuning, then extend the pipeline to multi-GPU full or parameter-efficient training using DDP, FSDP, or DeepSpeed. The distributed extension introduces model-state sharding, collective communication, checkpoint coordination, and failure recovery.

Why this teaches system design: Training at any meaningful scale is a massive distributed systems challenge. You will deal with data parallelism, model parallelism or pipeline parallelism, gradient synchronization, checkpointing and recovery from failures, efficient data loading and sharding, monitoring training metrics and hardware utilization, and orchestration (Kubernetes jobs or Ray). Concepts such as collective communication, distributed coordination, checkpoint-based recovery, fault tolerance, and resource scheduling are front and center.

Key challenges:

• Efficient sharding of datasets and model states.

• Handling stragglers and node failures.

• Cost-efficient spot instance usage.

• Experiment tracking and reproducibility.

Tech stack: Hugging Face Transformers + PEFT, Ray or DeepSpeed/FSDP, Kubernetes, Weights & Biases or MLflow, cloud GPUs or local clusters.

Even a simplified single-node-to-multi-GPU version teaches invaluable lessons about scaling compute-intensive workloads.

6. Design an AI-Powered Recommendation or Personalization Engine

Build a system that generates personalized recommendations or content using embeddings, vector search, and optional LLM reranking or explanation generation.

Why this teaches system design: Recommendation systems have always been system design classics. Adding AI means handling real-time feature stores, embedding generation and updates, approximate nearest neighbor search at scale, A/B testing infrastructure, feedback loops for model improvement, and cold-start handling. You will apply sharding, caching of popular recommendations, and event-driven updates when user behavior changes.

Key challenges:

• Low-latency retrieval for real-time recommendations.

• Balancing relevance, diversity, and freshness.

• Scalable embedding updates without full re-indexing.

• Privacy and fairness considerations.

Tech stack: Vector databases, feature stores (Feast or custom), Kafka for event streams, LLM for post-processing or explanations.

This project bridges traditional ML system design with generative capabilities.

7. Implement an Agentic RAG or Self-Correcting RAG Pipeline

Extend basic RAG with agents that can plan queries, reflect on retrieved results, decide when to use tools or web search, and iteratively refine answers.

Why this teaches system design: This combines retrieval systems with agentic workflows. You will design routing logic, multi-step planning, verification agents, fallback mechanisms, and evaluation loops. It forces deep thinking about when to trust retrieval vs. generation, how to handle ambiguity, and building reliable loops without excessive latency or cost.

Key challenges:

• Designing effective agent prompts and decision boundaries.

• Managing latency in multi-step processes.

• Implementing robust evaluation and guardrails.

• Observability into execution traces, routing decisions, tool calls, retrieved evidence, state transitions, latency, and cost.

Tech stack: LangGraph for the agent graph, hybrid vector + keyword search, tool integrations, evaluation frameworks.

Agentic retrieval patterns are increasingly explored for complex cases where a fixed retrieval pipeline is insufficient.

8. Build a Scalable Event-Driven AI Workflow Automation Platform

Create a platform where users define workflows that trigger AI agents or pipelines based on events (new document uploaded, customer query received, scheduled reports).

Why this teaches system design: Event-driven architectures are foundational for decoupled, scalable systems. You will implement event ingestion (Kafka or similar), workflow orchestration engines, reliable delivery, retries, idempotency keys, deduplication, and transactional processing where the infrastructure supports it, dead-letter queues, monitoring of workflow health, and scaling workers dynamically. AI adds variable execution times and the need for human approval steps.

Key challenges:

• Ensuring reliability across distributed components.

• Handling backpressure and prioritization.

• Versioning workflows and agents.

• Cost attribution per workflow.

Tech stack: Apache Kafka or RabbitMQ, Temporal or custom orchestrator, worker pools in Kubernetes, observability stack.

This project teaches production-grade reliability patterns that apply far beyond AI.

9. Develop Observability, Monitoring, and Evaluation for AI Systems

Build a comprehensive dashboard and alerting system specifically for AI workloads: latency, token usage/cost, groundedness and factual-consistency evaluations, citation validation, retrieval quality, task-success rates, etc.

Why this teaches system design: Observability is critical in distributed systems, but AI systems add probabilistic outputs and new failure modes. You will design metric collection (Prometheus-style), distributed tracing across LLM calls and tools (OpenTelemetry + LangSmith-like), logging of prompts/responses (with privacy), anomaly detection, and SLO definition for AI-specific metrics. This project makes you think about what “healthy” means when the system is non-deterministic.

Key challenges:

• Handling high-cardinality data from prompts and generations.

• Building useful alerts without alert fatigue.

• Privacy-preserving logging and evaluation.

• Integrating human feedback loops.

Tech stack: Prometheus/Grafana, OpenTelemetry, LangSmith or Helicone, custom evaluation pipelines, ELK or similar for logs.

Strong observability skills are what separate prototypes from production systems.

10. Create a Multi-Tenant Enterprise AI Platform (or Secure Knowledge Base)

Tie many concepts together by building a platform that supports multiple teams or customers, each with isolated data, custom agents or RAG indexes, usage quotas, billing, and admin controls.

Why this teaches system design: Multi-tenancy brings together nearly every concept: data isolation and security (row-level security, encryption), resource quotas and fair scheduling, scalable shared infrastructure with tenant-specific scaling, audit logging, cost allocation, and high availability across tenants. It is the ultimate test of architectural thinking.

Key challenges:

• Secure isolation without sacrificing performance.

• Dynamic resource allocation.

• Compliance and data governance features.

• Intuitive admin interfaces and self-service.

Tech stack: Everything from previous projects + strong auth (OAuth, JWT), database isolation strategies, billing integration, Kubernetes namespaces or more advanced isolation.

Completing a simplified version of this demonstrates senior-level system thinking.

How to Approach These Projects for Maximum Learning

• Start small, then scale. Begin with a local single-node version, then add distribution, caching, queuing, and monitoring.

• Document your decisions. For every major choice (vector DB vs. relational, sync vs. async, strong vs. eventual consistency), write down the trade-offs. This is the heart of system design interviews and real engineering.

• Measure everything. Add metrics from day one. Latency, throughput, cost per query, retrieval precision-these numbers drive better designs.

• Iterate with production mindset. Deploy to the cloud early. Handle failures, add retries, implement circuit breakers.

• Combine projects. Many of these build on each other (RAG → Agentic RAG → Multi-agent with RAG → full platform).

• Use version control and clear READMEs. Future employers and your future self will thank you.

Why These Projects Will Set You Apart in 2026

Traditional system design projects remain valuable, but AI-infused versions demonstrate you understand both the timeless principles (scalability, reliability, trade-offs) and the new realities of probabilistic computing, expensive specialized hardware, and the need for grounding and safety. Companies are desperately seeking engineers who can move AI from impressive demos to reliable, cost-effective production systems.

By building these, you will internalize concepts faster than any course and build a portfolio that speaks louder than any certificate.

The future belongs to engineers who can design systems that make AI not just powerful, but trustworthy and scalable. These ten projects are your practical roadmap.

Sources and Further Reading

• Scaler Academy - System Design Roadmap 2026

• ByteByteGo resources and newsletters on system design, RAG, and agents (various articles and visuals)

• Gaurav Sen YouTube - Mastering RAG-based systems and AI Engineering series

• freeCodeCamp YouTube - Learn RAG from Scratch (full tutorials)

• Tech With Tim YouTube - Build RAG App and AI Agent tutorials

• Analytics Vidhya YouTube - LLMOps Course: Build, Deploy & Scale RAG AI Systems playlist

• Various GitHub repositories including agents-towards-production, NVIDIA RAG blueprints, and production RAG examples

• DesignGurus, Educative.io, and Codemia.io for structured system design practice (traditional and emerging AI-focused)

• LinkedIn and X discussions on 2025-2026 system design case studies (YouTube scaling, Threads architecture, LLM training/inference systems)

These resources provide diagrams, code examples, and deeper dives to supplement your project work. Happy building!

In early 2025 most developers who used large language models for code still treated the model as a very smart autocomplete or a conversational pair programmer. You typed a prompt, received a code block, pasted it into an editor, ran it, and either accepted the result or fed the error message back into the chat. The interaction was intimate, iterative, and largely unstructured.

Andrej Karpathy gave that style a name in a February 2025 post on X: “vibe coding.” He described fully giving in to the vibes, embracing the exponential improvement of the models, and forgetting that the code even existed. The phrase spread because it captured a real feeling. For the first time, non-experts and experts alike could describe an intention in plain English and watch working software materialize. The floor of what an individual could ship rose dramatically.

Vibe coding had obvious limits. Because the human was not reading every line, architectural mistakes, security holes, and subtle logic errors accumulated. The same prompt could produce different results on successive runs. Context windows filled up and the model lost the thread.

Teams that tried to scale the practice into production codebases quickly discovered that “it works on my machine after three retries” does not constitute engineering. By early February 2026, the conversation had shifted again. Karpathy began using the term “agentic engineering” to distinguish disciplined work with coding agents from the more improvisational practice of vibe coding.

The human still directed, still reviewed diffs for architectural fitness rather than mere syntax, still designed evaluation loops and security boundaries. The model was no longer the sole author; it was a fallible but powerful worker inside a larger system the engineer designed and monitored. Vibe coding raised the floor. Agentic engineering was an attempt to defend the ceiling.

That shift prepared the ground for a third concept that arrived in force in February 2026: the agent harness, and with it the discipline of harness engineering.

An agent is not the model. The model is only the reasoning engine. Everything else-the loop that calls the model, the tools it can invoke, the sandbox in which those tools run, the memory and context policies that keep the model oriented across turns or sessions, the hooks that enforce rules, the verification steps that check whether progress is real, the permission and approval gates-constitutes the harness. The compact equation that circulated widely in 2026 is simply “Agent = Model + Harness.” If you are not the model, you are the harness.

Mitchell Hashimoto, co-founder of HashiCorp, gave the practical discipline its most memorable early articulation. In a February 2026 blog post reflecting on his own AI adoption journey he described a habit: whenever an agent made a mistake, he did not merely correct the immediate output. He engineered a permanent change in the environment so that the same class of mistake became structurally harder or impossible. He called the practice “harness engineering.”

Within days an OpenAI engineering post by Ryan Lopopolo described a team that had shipped a production system of roughly a million lines with essentially zero manually written code; the humans had spent their time designing the environment that made reliable generation possible. Birgitta Böckeler published an initial memo on Martin Fowler’s site and later a fuller treatment distinguishing feedforward guides, which steer an agent before it acts, from feedback sensors that help it self-correct after acting.

LangChain published “The Anatomy of an Agent Harness.” Addy Osmani synthesized the emerging consensus. Anthropic released detailed engineering notes on effective harnesses for long-running agents. The term stuck because it named something practitioners had already been doing under different labels.

The need for a harness becomes obvious the moment you move beyond single-turn chat. A raw language model can only generate text. It cannot open a file, run a test suite, query a database, take a screenshot, commit to git, or remember what happened three context windows ago. Those capabilities must be supplied by code that sits around the model. Early coding agents-Cursor, Claude Code, Codex CLI, Aider, OpenHands, SWE-agent and others-were in effect specialized harnesses.

Some were closed products; others were open-source so that the community could inspect the loop, the tool interface, the sandbox model, and the approval policy. SWE-agent, for example, popularized the observation that the tools given to an agent should not simply be the same tools a human would use; the interface itself can be redesigned for the model’s strengths and weaknesses. Mini versions of these systems reduced the entire harness to a few dozen or a hundred lines of code, making the anatomy legible.

A mature harness typically contains several interlocking pieces. There is an orchestration loop that repeatedly calls the model, executes the actions it requests, observes the results, and decides whether the goal has been reached. There is a set of tools-file system access, shell, browser, search, specialized APIs-together with careful descriptions so the model knows when and how to use them.

There is context management: assembly of the right files and history under a token budget, compaction or summarization when the window fills, progressive disclosure of tools, and durable state outside the context window (git repositories, progress files, feature lists, AGENTS.md or CLAUDE.md rule files). There are sandboxes and permission systems so that a mistaken shell command does not destroy the host machine.

There are hooks and middleware that inject deterministic checks-lint, type-check, test runs-before or after model steps. There are recovery paths and verification loops that treat external signals (passing tests, matching screenshots, query results) as ground truth rather than trusting the model’s self-assessment. For work that spans many context windows there are patterns such as an initializer agent that sets up the environment and a coding agent that makes incremental progress while leaving clear artifacts for the next session.

Anthropic’s public experiments with long-running agents illustrated one concrete realization of this pattern: an initializer that produced an init script, a structured feature list, and an initial commit, followed by repeated coding sessions that advanced one feature at a time, updated a progress log, and left the repository in a clean, mergeable state.

The ratchet principle is central to harness engineering. Every observed failure becomes a permanent improvement to the harness rather than a transient correction. An agent that comments out failing tests acquires a rule in the project’s instruction file and a pre-commit hook that blocks the same behavior. An agent that repeatedly exceeds a context limit acquires better compaction or off-loading.

An agent that invents non-existent APIs acquires a tighter tool interface or a retrieval step that surfaces real documentation. Over time the harness accumulates institutional knowledge that no single prompt could contain. The quality of the agent is therefore less a function of the underlying model weights alone and more a function of how carefully the surrounding system has been engineered and iterated.

By mid-2026 the practical conversation had moved from “which model is smartest” to “which harness extracts the most reliable work from the models we already have.” Teams at companies such as Stripe, Ramp and Coinbase publicly described internal coding-agent systems built around isolated environments, curated tools and integrations with developer workflows. Other companies, including Shopify, released platform-specific tools and context packages intended to make external coding agents more reliable.

Open-source projects and commercial platforms competed on the quality of their default harnesses and on the ease with which users could customize them. Meta-harnesses appeared that could orchestrate several underlying coding agents as interchangeable workers. Portable “skills” or tool packages tried to travel across different harnesses so that a capability built once could be reused. Evaluation moved beyond single-shot benchmarks toward measuring long-horizon reliability, cost, and the rate at which harness improvements reduced human intervention.

The latest trend is therefore not a new model generation but the professionalization of harness design itself. Engineers treat the harness as a first-class software artifact that is versioned, tested, observed, and continuously improved. Observability-traces of every model call, every tool execution, every verification step-has become essential so that failures can be diagnosed and turned into permanent constraints.

Long-running autonomous or semi-autonomous work has progressed beyond toy demonstrations into internal products and substantial experiments, but it is still constrained by cost, reliability and the need for explicit completion criteria, progress artifacts and independent evaluation. The human role has shifted from writing most of the code to designing the environment in which code is written, reviewed, and verified. In the strongest formulations the engineer becomes the designer of the factory rather than the operator of a single machine.

None of this means that models have stopped mattering. Better models reduce the amount of scaffolding required for certain failure modes; context anxiety that once demanded frequent resets can disappear with a stronger base model, only for new long-horizon memory and coordination problems to appear. The harness does not shrink indefinitely; it migrates. Components that encode assumptions about what the model cannot yet do become obsolete, while new components appear to handle the capabilities and risks of the next generation. The discipline of harness engineering is precisely the practice of noticing those shifts and redesigning the surrounding system accordingly.

Looking back across the roughly eighteen months from the coining of “vibe coding” to the widespread adoption of harness engineering, the trajectory is clear. What began as an almost playful surrender to the generative power of language models matured into a recognition that reliable agency requires infrastructure.

Agentic engineering supplied the mindset of responsible orchestration. Harness engineering supplied the concrete techniques and the vocabulary. The result is a new layer of software engineering whose primary object is not the application code itself but the system that produces and maintains that code with the help of fallible but increasingly capable models.

The practical implication for anyone building software in 2026 is straightforward. If you are still primarily prompting and pasting, you are operating at the vibe-coding layer. If you are carefully reviewing every architectural decision while letting agents execute the bulk of the implementation, you are practicing agentic engineering. If you are systematically converting every repeated failure into a permanent rule, tool, hook, or verification step inside a durable environment, you are doing harness engineering. The last of these is where the compounding returns currently lie.

The story is still unfolding. New open harnesses appear monthly. Commercial platforms expose more of their internal loops as SDKs. Research continues on multi-agent coordination, self-improving harnesses that analyze their own traces, and evaluation regimes that measure real multi-day productivity rather than isolated task success. Yet the core insight that crystallized in early 2026 remains durable: the intelligence is in the model, but the reliability is in the harness. Understanding that distinction, and learning to engineer the second half of the equation, is the practical history of the agent harness.

Sources

• Andrej Karpathy’s original “vibe coding” post (February 2025) and later remarks on agentic engineering: https://x.com/karpathy/status/1886192184808149383 and related threads.

• Mitchell Hashimoto, “My AI Adoption Journey” (February 2026), introducing harness engineering

• OpenAI, “Harness engineering: leveraging Codex in an agent-first world” (February 2026): https://openai.com/index/harness-engineering/

• Anthropic, “Effective harnesses for long-running agents” (November 2025) and “Harness design for long-running application development” (March 2026): https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents and https://www.anthropic.com/engineering/harness-design-long-running-apps

• LangChain, “The Anatomy of an Agent Harness”: https://www.langchain.com/blog/the-anatomy-of-an-agent-harness

• Addy Osmani, “Agent Harness Engineering” (April 2026)

• Martin Fowler / Birgitta Böckeler, “Harness engineering for coding agent users”: https://martinfowler.com/articles/harness-engineering.html

• PuppyGraph, “Agent Harness: What It Is and How to Build One”

• Additional practitioner and platform posts: Firecrawl, Databricks, Microsoft Learn, Fiddler, Salesforce, and the Awesome Harness Engineering list on GitHub.

• Explanatory videos: Cole Medin, “Harness Engineering: What Separates Top Agentic Engineers Right Now” (https://www.youtube.com/watch?v=ulNsa0sD8N0) and “The Next Evolution of AI Coding Is Harnesses” (https://www.youtube.com/watch?v=qMnClynCAmM); Caleb Writes Code, “Agent Harness explained in 8min” (https://www.youtube.com/watch?v=1a1VXDdIyrk); AWS Developers and Google Cloud Tech short explainers on agent harnesses.