On March 31, 2026, Anthropic accidentally exposed more than 500,000 lines of Claude Code's source code. For developers, the incident offered an unusually detailed look inside one of the industry's most advanced AI coding agents.
Six months later, the AI coding landscape looks substantially different.
OpenAI Codex has evolved toward managed agent infrastructure. Cursor is coordinating large numbers of agents across persistent projects. Google's Gemini ecosystem is expanding specialized agents and cloud execution. OpenCode is making agent workflows increasingly portable between model providers.
The biggest change isn't simply that AI models are becoming better at writing code. It's that the software surrounding those models is becoming far more capable.
A July 2026 research paper examining 11 coding-agent systems found concrete evidence of architectural convergence, including cases where competitors adopted Claude Code's conventions.
The findings point toward a new phase of AI software engineering: moving beyond generating code to planning, executing, testing, and maintaining entire projects.
What Actually Happened With the Claude Code Source-Code Leak?
On March 31, 2026, Anthropic released Claude Code version 2.1.88 with an unintended debugging source-map file included in its npm package.
That file exposed approximately:
- 512,000 lines of TypeScript code
- 1,900 source files
- Internal agent loops and tool execution systems
- Permission controls and context-management mechanisms
- Multi-agent orchestration and details of unreleased features
Anthropic attributed the exposure to a release-packaging mistake caused by human error, not an external security breach.
Importantly, the leak did not expose the Claude AI model itself.
Instead, it exposed the software responsible for turning the language model into a functioning coding assistant.
That distinction is essential.
The model is responsible for understanding instructions and generating responses. The surrounding software determines which files the model can inspect, which commands it can execute, how it remembers previous work, and what happens when something goes wrong.
In AI engineering, this surrounding software is commonly called the agent harness.
What Is an AI Agent Harness, and Why Does It Matter?
An AI coding agent is more than a language model connected to a terminal.
Consider a developer asking an agent to add Stripe subscriptions to an existing web application.
The model might understand Stripe's APIs and generate TypeScript code. But completing the assignment requires substantially more work.
The agent needs to inspect the existing authentication system, understand the application's architecture, identify relevant files, install dependencies if necessary, make coordinated changes, execute tests, and handle errors.
It may also need to remember instructions given earlier in the project.
The harness handles the infrastructure that allows those activities to happen.
| Harness component | What it does | Why it matters |
|---|---|---|
| Agent loop | Repeatedly evaluates results and decides the next action | Enables multi-step work |
| Tool execution | Connects the model to files, terminal commands, and external services | Turns generated responses into actual changes |
| Context management | Selects, summarizes, and preserves relevant information | Helps agents work with large codebases |
| Memory | Retains useful knowledge across tasks or sessions | Reduces repeated onboarding |
| Permissions and sandboxing | Controls which actions an agent can perform | Reduces security and operational risks |
| Subagent orchestration | Delegates specialized work to other agents | Supports parallel development |
| Verification and recovery | Checks results and handles interruptions | Improves reliability |
Two agents using similarly capable models can produce very different results because their harnesses manage these responsibilities differently.
A stronger model may generate better code initially. A better harness can help an agent understand the correct files, maintain context, catch mistakes, and complete more of the assignment.
For complex software development, the quality of the system increasingly matters alongside the quality of the model.
Researchers Compared the Source Code of 11 AI Agent Harnesses
In July 2026, researchers Paul Barbaste, Tristan Darrigol, Germain Vu, and Tom Wiltberger published Harness Engineering: Anatomy, Architecture, and Evolution of Coding Agents - A Source-Code Study of Eleven Systems.
The study examined production implementations of Claude Code, Codex CLI, Gemini CLI, Mistral Vibe, OpenHands, Aider, Mini-SWE-Agent, Hermes, Pi, OpenCode, and OpenClaw.
It also examined Omnigent as a separate example of a system coordinating multiple agent harnesses.
The researchers analyzed approximately four million lines of code across the systems and identified 29 recurring architectural patterns.
More importantly, they compared eight systems against earlier snapshots from April 2026.
That made it possible to examine how these agent implementations changed over approximately three months.
The surprising discovery: convergence became imitation
In the earlier research, competing harnesses had implemented many similar ideas independently.
By July, the researchers could identify specific cases where one implementation adopted another's established conventions.
For example:
| Agent harness | Observed development |
|---|---|
| OpenAI Codex | Adopted Claude Code's hook-event vocabulary and plan-mode ergonomics |
| OpenHands | Adopted Claude Code's plugin manifest format and elements of its task and caching architecture |
| OpenCode | Added support for reading Claude Code skill directories |
| Hermes Agent | Explicitly referenced architectural ideas from OpenCode, Codex, OpenClaw, and Goose |
| Gemini CLI | Expanded specialized subagents and isolated execution contexts |
This is more substantial than several companies independently adding a planning button.
It shows identifiable architectural conventions spreading between competing products.
However, there is an important qualification.
The study does not prove that competitors copied code from Anthropic's March leak.
Some concepts predated the incident. Similar solutions can emerge from similar engineering problems, and public documentation and open-source development also influence the ecosystem.
What the research establishes is that competing harnesses increasingly share implementation patterns and interfaces.
The leaked Claude Code source made one influential implementation easier to inspect, but its measurable effect on competing products remains unknown.
How Fast Did Coding-Agent Architecture Change?
The research documented several architectural patterns becoming more common between April and July 2026.
| Capability | April 2026 | July 2026 |
|---|---|---|
| Deferred tool loading | 1 system | 3 systems |
| Read-only planning modes | 2 provider-native harnesses | All 4 provider-native harnesses |
| LLM-based approval classifiers | 1 system | 2 systems |
| Turn-level checkpointing | 1 system | 3 systems |
These numbers refer to the research sample, not the entire AI coding-agent industry.
Nevertheless, they illustrate how quickly features that once distinguished individual products began appearing elsewhere.
Deferred tool loading lets an agent discover tools when needed rather than carrying every tool description in its active context.
Read-only planning modes let agents analyze a problem before receiving permission to modify files.
Approval classifiers can help evaluate potentially risky operations.
Checkpointing makes it easier to recover work when a long-running process is interrupted.
None of these capabilities necessarily improves every coding task. But together, they address a fundamental limitation of early AI coding tools: the difficulty of reliably completing work that involves many dependent steps.
How the Major AI Coding Agents Evolved by October 2026
The most interesting development is that competing companies aren't pursuing identical solutions.
They increasingly share basic architectural concepts while differentiating themselves through execution, memory, orchestration, and deployment.
OpenAI Codex: From Coding Assistant to Managed Agent Infrastructure
Codex has moved beyond its original role as a tool for interacting with and modifying code.
Its architecture includes sophisticated session management, subagent coordination, permissions, sandboxing, and context handling.
The significant commercial development came on September 10, 2026, when OpenAI introduced the Agents API.
The API exposes the managed harness and infrastructure behind Codex, allowing developers to build agents without implementing every part of the execution environment themselves.
It supports capabilities such as context compaction, orchestration, recovery, tool use, and sandboxed execution.
Consider a business building an internal agent to investigate technical incidents.
Instead of creating a custom execution loop, context-management system, and recovery infrastructure, its developers can use the managed harness and concentrate on the actual business workflow.
This points toward an important evolution.
The coding-agent harness is becoming reusable infrastructure, rather than functionality confined to a single developer application.
Codex's strategic direction is to make sophisticated agent execution accessible through both development tools and managed services.
Cursor: From Interactive Coding to Coordinated Agent Fleets
Cursor is taking a different approach, with increasing emphasis on entire projects rather than isolated coding sessions.
On September 10, 2026, Cursor introduced Projects.
According to Cursor, Projects can maintain shared context over months, coordinate thousands of subagents, and perform recurring work without requiring a fresh prompt for every operation.
Its coordinator agent plans work and delegates implementation to other agents.
Those agents can operate in cloud environments that continue running after the developer closes their laptop.
For example, a large application migration could involve separate agents updating components, modifying tests, investigating failures, and preparing changes for review.
The coordinator manages the larger body of work.
Cursor also introduced persistent project context, allowing agents to share discoveries about the repository and its development processes.
These capabilities are significant because developers spend considerable time repeatedly explaining existing systems to their tools.
Persistent context can reduce that overhead.
However, coordinating thousands of possible subagents is not the same as demonstrating that thousands of agents can productively collaborate on any project. Parallel execution introduces costs, coordination problems, and integration risks.
Cursor's direction is nevertheless clear.
The developer increasingly supervises the work, rather than personally managing every coding interaction.
Gemini CLI: Specialized Agents and Managed Execution
Google's agent ecosystem has evolved along two related paths.
On April 15, 2026, Google announced subagents for Gemini CLI.
Each subagent can operate with its own context window, instructions, tools, and MCP servers.
This separation is useful for complex development tasks.
For example, an agent investigating database performance can work independently from another examining frontend rendering problems.
The main agent receives summarized findings instead of accumulating every intermediate command and file inspection in its own context.
That helps reduce unnecessary context consumption.
On May 19, Google also introduced Managed Agents through the Gemini API, powered by its Antigravity agent.
This offering supports execution in isolated cloud environments and reusable instructions defined through files such as AGENTS.md and SKILL.md.
Although Gemini CLI and the managed service are distinct products, both illustrate Google's broader investment in reusable, specialized agent systems.
Google's advantage is the potential to integrate these capabilities with its AI models, cloud infrastructure, and developer ecosystem.
OpenCode: Flexibility Without Dependence on One Model Provider
OpenCode has focused heavily on configurability and extensibility.
Its architecture supports configurable model providers, different agent roles, child sessions, tool permissions, and reusable skills.
One particularly useful development is its compatibility with Claude Code's skill directory convention.
Developers can place reusable instructions in .claude/skills and have OpenCode discover them.
That reduces the effort required to move certain workflows between agent environments.
This matters because developers may want different models for different types of work.
A model that performs well on complex architecture questions may not be the most economical choice for straightforward file changes.
A provider-independent harness gives developers more freedom to choose.
OpenCode's approach reflects a different competitive strategy: instead of providing one tightly integrated model-and-agent combination, it offers a configurable environment that can adapt to changing providers and workflows.
One of the Biggest Findings: None of the 11 Harnesses Used a General-Purpose Agent Framework as Its Runtime
One result from the research deserves particular attention.
Across approximately four million lines of analyzed source code, the researchers found that none of the 11 harness runtimes depended on a general-purpose agent framework such as LangChain or LangGraph.
They also found that none used vector-embedding retrieval to search source code.
Instead, the systems generally relied on custom execution loops, conventional code-search mechanisms, and purpose-built context management.
This doesn't mean frameworks or vector databases are useless.
Those technologies can be valuable for applications involving document retrieval, enterprise knowledge bases, or workflows where their abstractions are appropriate.
And it doesn't mean coding agents never use semantic techniques to reason about code.
The finding is narrower: the analyzed harness implementations did not use vector embeddings as their code-retrieval mechanism.
For software engineering, deterministic search tools remain extremely useful.
Searching for a function name, following imports, inspecting file structure, or examining a specific Git diff frequently provides more predictable results than retrieving semantically similar code fragments.
The larger lesson is that reliable AI agents depend on careful systems engineering, not necessarily more layers of AI abstraction.
A well-designed execution loop with effective tools, permissions, and context selection may deliver more practical value than a complicated framework that introduces unnecessary overhead.
The Next Competitive Advantage Is Memory, Not Just Intelligence
Large software applications contain information that rarely fits comfortably inside one AI conversation.
A production SaaS platform may have hundreds of thousands of lines of code, multiple integrations, years of architectural decisions, and business rules that aren't obvious from reading individual files.
Even a powerful AI model will struggle if it repeatedly loses the context necessary to understand the application.
This is why memory and context engineering have become such important areas of competition.
There are several different problems to solve.
Session context concerns what the agent needs to know while performing its current assignment.
Persistent memory concerns what should survive after that assignment finishes.
Shared project knowledge concerns information discovered by one agent that could benefit others.
These categories should not be confused.
A system that can summarize a long conversation doesn't necessarily understand the project's history. Likewise, saving every conversation does not guarantee useful memory.
Effective memory requires selecting what matters, preserving accurate information, and making it available when relevant.
For long-running development work, the objective should be simple: an agent should not need to rediscover the same project conventions every morning.
From Generating Code to Maintaining Entire Projects
The evolution of AI coding agents can be understood in three broad stages.
2025: Make the Model Write Code
The main attraction was the ability to describe a feature in natural language and receive working code.
Tools became increasingly capable of reading files, making edits, and executing terminal commands.
Developers still supervised most of the process closely.
Early to Mid-2026: Make the Agent Reliable
The focus expanded toward planning, permissions, context compaction, specialized subagents, verification, and recovery.
Generating the correct code became only one part of the problem.
The agent also needed to apply it safely and understand whether it worked.
Late 2026 and Beyond: Make Agents Run Projects
The emerging objective is more ambitious.
An agent receives a larger assignment, retains context, delegates independent work, executes tests, handles interruptions, and returns completed results for review.
Some systems can already perform recurring operations or continue executing remotely without an active developer session.
But this doesn't mean software development has become autonomous in the full sense.
Complex systems still need architectural judgment, security review, business-context understanding, and responsibility for production outcomes.
The next challenge is not simply making agents work longer.
It's making them work correctly for longer, with less supervision and without accumulating hidden mistakes.
What This Means for Businesses and Software Engineering Agencies
For businesses investing in custom software, AI coding agents could change how development work is organized.
The potential benefits go beyond generating features faster.
Existing software may become easier to maintain
Maintenance is one of the least glamorous and most expensive parts of software development.
Applications accumulate outdated dependencies, inconsistent components, technical debt, and unfinished improvements.
Persistent agents could help identify and address some of that work continuously.
But automated maintenance must be paired with testing and controlled deployments. A completed code change is not necessarily a safe production change.
Development teams may become more productive without growing at the same rate
A smaller engineering team could potentially coordinate multiple agents handling well-defined tasks.
One agent might investigate a bug while another prepares tests and a third updates documentation.
Human engineers would still need to review results, resolve conflicting changes, and make technical decisions.
The productivity gain depends on how much useful work agents complete relative to the time required to manage and verify them.
Software architecture may become even more important
There's an assumption that increasingly capable coding agents will make software architecture less relevant.
I suspect the opposite.
Clearly separated modules, predictable conventions, reliable tests, and documented business rules all make autonomous development easier.
A poorly structured application creates problems for human engineers and AI agents alike.
The difference is that AI agents can generate changes much faster than developers can manually review them.
That makes architectural discipline and verification more important, not less.
Security and accountability become critical
An agent that can read a repository is fundamentally different from one that can modify production infrastructure, access customer data, or deploy software.
Businesses need clear controls over permissions, credentials, approval requirements, audit logs, and rollback procedures.
Cloud execution and third-party integrations introduce additional considerations around data access and confidentiality.
Before giving an agent more autonomy, organizations should be confident that they can understand what it did and recover if something goes wrong.
Did the Claude Code Leak Actually Accelerate the Competition?
The answer is plausible, but not conclusively measurable.
We can establish three separate observations.
First, Anthropic's internal harness implementation became publicly accessible. Developers gained visibility into its architecture, tool systems, permission controls, and context-management techniques.
Second, subsequent research documents competing harnesses adopting similar implementation patterns. In several cases, researchers identified direct compatibility decisions and recognizable architectural conventions.
Third, the industry was already moving quickly before the leak. Subagents, persistent context, cloud execution, and permission systems were being developed independently across several products.
What we cannot reliably establish is how much faster any competitor improved specifically because of the exposed source code.
There is no credible basis for assigning a percentage improvement in coding performance to the incident.
The more important development is that useful agent architectures are increasingly visible, reusable, and interoperable.
Competitors can learn from established conventions while differentiating their own implementations.
This is familiar territory in software engineering.
Once effective patterns become understood, they tend to spread.
What Comes Next for AI Coding Agents in 2027?
I expect competition to concentrate on three areas.
1. Reliable long-running execution
The ability to operate for hours or days will matter only if agents can detect failures, recover from interruptions, and verify their results.
A system that works for six hours and produces an incorrect implementation is not necessarily better than one that completes a smaller task correctly.
Reliability will be a more meaningful differentiator than uninterrupted execution time alone.
2. Persistent project understanding
The best agents will need to retain architectural decisions, project conventions, previous failures, and useful discoveries across sessions.
They should also recognize when old information is no longer correct.
The challenge is not building the largest possible memory. It's maintaining the most useful and accurate understanding of a project.
3. Verifiable autonomous development
More coding work will likely be delegated to agents, but the output must remain inspectable.
Automated testing, code review, security checks, deployment controls, and audit trails will become essential parts of agent infrastructure.
The strongest systems may not be those that require the fewest human interactions under all circumstances.
They may be those that know which decisions can safely be automated and which require human judgment.
Final Thoughts: The Harness May Matter as Much as the Model
The Claude Code leak revealed how much engineering goes into building a serious AI coding assistant.
The months that followed demonstrated an even more important development.
Competing products increasingly share fundamental architectural ideas, but they are pursuing different approaches to orchestration, memory, extensibility, and execution.
OpenAI is making its Codex harness available as managed infrastructure. Cursor is moving toward persistent project-level coordination. Google is investing in specialized and managed agents. OpenCode is emphasizing flexibility and portability.
For developers, this means evaluating an AI coding tool requires looking beyond model benchmarks.
For businesses, it means the opportunities and risks of AI-assisted software development will depend increasingly on the systems controlling the AI.
At abz.global, where our work involves building and maintaining web applications and custom software, this is the development worth paying attention to.
Writing code is only one part of software engineering.
Understanding requirements, preserving architecture, verifying changes, integrating systems, and maintaining applications over time are equally important.
AI agents are beginning to take on more of those responsibilities.
The next major improvement in AI software engineering might not come from a dramatically more intelligent model.
It might come from a better harness that allows the intelligence we already have to complete real engineering work more reliably.
If you're planning a web app or want AI agents working inside your product, send us a brief.
Frequently Asked Questions
What is an AI coding-agent harness?
An AI coding-agent harness is the software infrastructure surrounding a language model that enables it to work with files, execute tools, manage context, enforce permissions, delegate tasks, and verify results. The harness turns the model's reasoning capabilities into practical software-development actions.
Was the Claude AI model's source code leaked in March 2026?
No. Anthropic accidentally exposed the TypeScript source code of Claude Code's agent application through a source-map file included in its March 31, 2026 release. The underlying Claude model and its weights were not part of that exposure.
Did OpenAI Codex copy Claude Code after the leak?
A July 2026 source-code study identified examples of Codex adopting Claude Code conventions, including hook-event terminology and planning interfaces. However, the research does not establish that OpenAI copied leaked source code or that the leak directly caused those implementation decisions.
What is the difference between an AI model and an AI agent?
An AI model processes inputs and produces outputs. An AI agent combines a model with software that enables it to interact with tools, execute actions, maintain context, and work through multiple steps toward a goal.
Why is context management important for AI coding agents?
Context management helps agents preserve relevant information while working with large codebases and long-running tasks. Without it, agents may lose earlier instructions, overlook important files, repeat investigations, or make changes inconsistent with existing architecture.
Can AI coding agents autonomously maintain an entire software project?
AI coding agents can already complete multi-step assignments, perform tests, coordinate subagents, and execute some ongoing maintenance tasks. However, reliably maintaining a complex production application without human oversight remains an unsolved challenge, particularly around architecture, security, business requirements, and deployment safety.
Will better harnesses reduce the need for more powerful AI models?
Better harnesses can improve practical results without requiring a new model, especially through improved tooling, memory, context management, and verification. However, model capabilities remain important. The strongest systems will likely combine improvements in both the underlying models and their execution infrastructure.