Confucius Code Agent: An Open-Source AI Software Engineer Built for Industrial-Scale Codebases

Have you ever imagined having an indefatigable AI programming partner that can understand massive projects and help you fix complex bugs? Today, open-source AI coding assistants are proliferating, but when we throw them into real-world, industrial-scale codebases—often spanning millions of lines with intricately interconnected modules—they often “freeze.” They either get lost in lengthy context or act like amnesiacs, unable to learn from past experience.

Meanwhile, closed-source commercial tools like Cursor and Claude Code, while powerful, have internal mechanisms that are black boxes. You cannot customize them, auditing is difficult, and they pose potential security and compliance risks when handling sensitive code.

Is it possible to create an AI software engineer that is both powerful enough for industrial-scale实战 and completely transparent, extensible, and controllable? A research team from Meta and Harvard University answers with a resounding yes, introducing the Confucius Code Agent (CCA).

Abstract

The Confucius Code Agent (CCA) is an open-source AI software engineer built on the Confucius SDK, designed to handle industrial-scale software engineering tasks. It tackles long-context reasoning challenges through hierarchical working memory and context compression, achieves cross-session memory and learning via a persistent note-taking system, and coordinates complex toolchains using a modular extension system. On the authoritative SWE-Bench-Pro benchmark, CCA achieved a Resolve@1 score of 54.3%, surpassing existing solutions, including proprietary closed-source systems. This demonstrates that superior intelligent agent framework design can outweigh mere improvements in foundational model capabilities.

The Open-Source vs. Closed-Source Dilemma: A Crossroads for Industrial-Grade Coding Agents

Software engineering has become a critical frontier for large language models (LLMs). From simple code completion to competitive programming problem-solving and resolving real GitHub repository issues, AI’s capabilities are constantly expanding. To support these complex tasks, numerous agent frameworks have emerged, equipping LLMs with tools like search, code editing, and command execution.

However, as AI evolves from a simple coding assistant to a “software engineer” that needs to operate within real, vast code repositories, developers face a sharp choice: opt for transparent but limited open-source solutions, or choose powerful yet closed proprietary systems?

Existing open-source coding agents, while transparent and reproducible, are often designed for narrower tasks using heuristic pipelines, struggling when confronted with large codebases. In contrast, modern proprietary systems like Cursor and Claude Code have become the de facto choice for handling large-scale software engineering workflows. Although efficient, they are closed “black boxes”—lacking transparency, having limited extensibility, opaque reasoning processes, and posing potential leakage or compliance risks when handling sensitive code.

This矛盾 is further amplified in industrial-scale codebases. These repositories are orders of magnitude larger than typical benchmark projects, contain deeply interdependent components, and evolve continuously. Practice shows that existing open-source coding agents fall short in two core challenges:

• Challenge One (C1): Long-Context Reasoning. Agents need to not only understand large files but also locate relevant code segments within massive repositories and perform multi-hop reasoning across分散的 modules and lengthy execution traces.
• Challenge Two (C2): Long-Term Memory. Effective agents should accumulate persistent knowledge—learning from successes and failures, retaining useful patterns and invariants, and avoiding repeated invalid actions or dead-end strategies across different tasks and sessions.

Beyond agent-level challenges, there exists a broader system-level gap: the lack of a development platform explicitly designed to optimize: 1) how LLM agents see, think, and learn (Agent Experience, AX), 2) how end-users understand, trust, and interact with them (User Experience, UX), and 3) how agent developers observe, evaluate, extend, and maintain them (Developer Experience, DX).

Figure 1: Confucius SDK overview. It unifies an orchestrator for iterative reasoning and action execution, long-term memory for continual learning, and modular extensions for tool use and interaction with the external environment.

The Solution: The Confucius SDK with AX/UX/DX at Its Core

To build powerful, trustworthy, and maintainable AI software engineers, what’s needed is an open, extensible development platform that explicitly balances AX, UX, and DX, rather than optimizing for just one dimension.

This is the premise of the Confucius SDK. It is an extensible, production-grade agent development platform designed around these three axes. On this foundation, the team instantiated its first agent: the Confucius Code Agent (CCA), an AI software engineer designed for real-world, industrial-grade development.

So, how exactly do the Confucius SDK and CCA address those core challenges? It’s achieved through four key features:

Figure 2: An illustration of AX, UX, and DX. Most frameworks implicitly optimize for a single audience, while Confucius SDK treats all three as first-class and interdependent design concerns.

F1: Context Management — Keeping AI Focused in Ultra-Long “Conversations”

Running agents on large repositories quickly stresses even long-context LLMs: lengthy debugging sessions, multi-file refactors, and nested tool calls lead to unbounded conversation growth. Many existing frameworks either accumulate a single flat history (risking context limits and “forgetting” early decisions) or rely on naive truncation and ad-hoc retrieval, which can silently drop critical information.

The Solution: CCA introduces an explicit agent context management layer, combining hierarchical working memory with adaptive context compression.

• Hierarchical Working Memory: Each agent instance is backed by a hierarchical working memory with configurable visibility scopes (e.g., session, entry, runnable). This acts like a structured mind map, helping the agent maintain important state throughout execution.
• Adaptive Context Compression: When the effective prompt length approaches a threshold, a planner agent called the “Architect” is invoked. It analyzes the conversation history and constructs a structured summary that explicitly preserves key information categories (e.g., task goals, decisions made, open TODOs, critical error traces). The system then replaces marked historical messages with this compressed summary while keeping a rolling window of recent messages in their raw form.

The Impact: This design not only preserves semantically crucial information but can reduce prompt length by over 40% without altering the underlying orchestrator or extensions, making long software engineering sessions on industrial codebases feasible.

Figure 3: Context compression overview. When the context window approaches configurable thresholds, the Architect agent summarizes earlier turns into a structured plan containing goals, decisions, errors, and open TODOs. These compressed summaries replace original large spans of history while preserving a short window of recent interactions, enabling sustained multi-step reasoning over long trajectories without exceeding context limits.

F2: The Note-Taking Agent — Building an Accumulative, Retrievable “Experience Library” for AI

Flat chat logs are not ideal for long-term memory: they are verbose and hard to reuse. In typical frameworks, any cross-session “memory” is either absent or implemented via coarse-grained embeddings over entire turns, often missing important structures like architecture, design decisions, and failure modes.

The Solution: CCA incorporates an explicit note-taking functionality that turns interaction traces into structured, persistent knowledge.

• Structured Notes: A dedicated note-taking agent (also built on the Confucius orchestrator) distills each interaction “trajectory” into compact Markdown notes, stored in a filesystem-like tree structure.
• Hindsight Notes: Its distinctive feature is the emphasis on hindsight notes for failures. The system encourages agents to record not just successful solutions, but also compilation errors, runtime exceptions, and unproductive strategies, along with the eventual resolution or reason for abandonment.

The Impact: Over time, this builds a corpus of failure cases indexed by error messages, stack traces, and affected components. When a similar failure appears in a future session, the agent can retrieve the corresponding note and immediately surface known fixes or workarounds, rather than rediscovering them from scratch. This provides AI with the capacity for continuous learning and avoiding repeated mistakes.

F3: The Extension System — Building and Customizing AI Capabilities Like Building Blocks

At the heart of the Confucius SDK is a minimal yet extensible Orchestrator that repeatedly calls the LLM, parses its outputs, and coordinates tool use. What truly赋予 the agent specific capabilities are Extensions.

The Solution: Nearly all agent behaviors are factored into modular extensions that attach to the orchestrator and participate in each loop iteration. Extensions intervene in the process by registering callback functions, for example:

• Perception Extensions: Parse raw model outputs into structured actions (e.g., interpreting file-edit tags).
• Reasoning Extensions: Rewrite or annotate messages before LLM invocation (e.g., adding planning instructions).
• Action Extensions: Execute tools (shell commands, function calls, etc.) and persist results.

The Impact: This offers several benefits. First, extensions can be composed and reused across different agents. Second, behaviors are easier to observe and ablate because each extension has a narrow, well-defined contract. CCA itself is an orchestrator instance bundled with a specific set of extensions like file-editing, CLI, code search, and planning. This means any improvement made to CCA’s extensions can be immediately reused by other agents built on the Confucius SDK.

F4: The Meta-Agent — Letting AI Design and Optimize AI

A recurring limitation of existing agent frameworks is that agent behavior is largely static: humans manually design prompts, tool wiring, and guardrails, then revise them periodically through trial and error. This is labor-intensive, doesn’t scale with growing tool ecosystems, and makes it difficult to adapt agents to new tool stacks and environments.

The Solution: The Confucius SDK introduces a Meta Agent that automatically builds and refines other agents through an explicit “build-test-improve” loop.

• Automated Process: A developer describes the target agent’s purpose in natural language. The Meta Agent generates a structured configuration, automatically synthesizes the agent’s configuration and prompts, and wires in the selected extensions.
• Automated Testing & Debugging: The Meta Agent drives the candidate agent locally on a set of regression tasks, observing its outputs, logs, and tool traces. When it detects failures or undesirable behaviors, it proposes concrete modifications to prompts, extension configurations, or even new tool wrappers, then reruns the test loop until target metrics are met.

The Impact: In fact, the production-grade CCA presented in this article is itself the product of this Meta Agent build-improve-test loop. The resulting agent shows more reliable tool selection and recovery behaviors than our initial hand-written designs. The same interface allows enterprise users to rapidly spin up organization-specific agents.

Figure 4: Meta-agent build–test–improve loop. The Meta-agent synthesizes agent configurations, wires together orchestrator components and extensions, evaluates candidate agents on representative tasks, and iteratively refines prompts and tool-use policies based on observed failures.

Empirical Validation: How Does CCA Perform on Industrial-Grade Benchmarks?

Brilliant theoretical design requires validation in实战. The research team conducted comprehensive evaluations of CCA across multiple benchmarks.

The Main Battleground: SWE-Bench-Pro

SWE-Bench-Pro is a public dataset containing 731 tasks designed to assess an agent’s ability to solve long-horizon, enterprise-level software engineering problems. The team followed identical environment and infrastructure configurations as baseline methods.

The core findings are exciting:

• Using the same Claude 4 Sonnet model, CCA achieved a resolve rate (Resolve@1) of 45.5%, outperforming the baseline SWE-Agent’s 42.7%.
• With the stronger Claude 4.5 Sonnet model, CCA reached 52.7%, significantly surpassing the current best open-source agent, Live-SWE-Agent, at 45.8%.
• Even with the top-tier Claude 4.5 Opus model, CCA achieved a 54.3% resolve rate, exceeding the 52.0% reported by Anthropic’s own proprietary framework and setting a new state-of-the-art performance.

This reveals a key insight: These improvements stem purely from a more powerful agentic framework—enhanced orchestration, context management, and tool-use extensions—not from differences in the foundational model or evaluation setup. Remarkably, a weaker model equipped with a strong agent framework (Claude 4.5 Sonnet + CCA, 52.7%) can outperform a stronger model paired with a weaker framework (Claude 4.5 Opus + proprietary framework, 52.0%). This underscores that the agent framework itself is a decisive factor in real-world software engineering task performance.

Deep Dive: How Much Does Each Feature Contribute?

To quantify the impact of each core feature, the team conducted systematic ablation studies.

1. The Power of Context Management: On a 100-task subset of SWE-Bench-Pro, enabling hierarchical memory and context compression boosted CCA’s resolve rate from 42.0% to 48.6% using Claude 4 Sonnet, a gain of +6.6 percentage points. Manual inspection revealed that the planner agent often reduced prompt length by over 40% without omitting key reasoning chains.

2. The Value of Meta-Agent Learned Tool Use: On the same subset, disabling the “advanced” tool-use patterns learned by the Meta-Agent (like file editing and command-line operations) and reverting to a “simple”模式 similar to traditional agents caused a significant performance drop, even with context management kept constant. This confirms that tool-use conventions learned by the Meta-Agent are a major driver of CCA’s performance.

3. The Effect of Notes for Continuous Learning: To evaluate long-term memory, the team ran a two-pass experiment on 151 tasks. In the first pass, the Note-Taker agent ran tasks from scratch and generated notes. In the second pass, CCA re-ran these tasks with access to the first-pass notes.

   • Results: Average turns decreased from 64 to 61.
   • Token cost dropped from 104k to 93k.
   • Resolve rate increased slightly from 53.0% to 54.4%.
     This indicates the note-taking system provides a lightweight form of cross-session learning, enabling more efficient reasoning and more reliable patch generation in subsequent attempts.

Comparison with Traditional Open-Source Frameworks: SWE-Bench-Verified

CCA also excelled on the widely-used SWE-Bench-Verified benchmark. Using the Claude 4 Sonnet model, CCA achieved a 74.6% resolve rate, surpassing the strongest open-source system, OpenHands (72.8%), under the same backbone model, and also beating a mini-SWE-Agent variant that used the stronger Claude 4.5 Sonnet model (70.6%). This again reinforces the critical role of the agent framework.

In the Trenches: CCA vs. The Closed-Source Star, Claude Code

Beyond standardized benchmarks, the research team designed a more实战-oriented “micro-benchmark”—PyTorch-Bench. They selected 8 real, complex, and reproducible GitHub issues from the PyTorch repository and compared the solutions generated by CCA and Anthropic’s closed-source tool, Claude Code (CC), under identical hardware (NVIDIA A100 80GB GPU) and model (Claude Sonnet 4.5) conditions.

Expert review revealed interesting behavioral differences:

• Case 1: CUDA Memory Checkpoint Assertion Failure: Faced with a complex CUDA graph checkpointing error, both CCA and CC identified the root cause but proposed截然不同的 solutions. CCA viewed the relevant assertion as overly restrictive and opted for minimal intervention (removing 2 problematic lines of checks). CC considered the assertion an important architectural guardrail and pursued a more holistic solution (adding 7 lines of logic to explicitly handle edge conditions). Ultimately, the PyTorch core team’s official fix aligned with CCA’s approach, validating its “precision surgery” engineering style.
• Case 2: Memory Issues in Llama-2 Training: For an issue where GPU memory reclamation was too aggressive, CCA identified the core矛盾 and implemented a simple guard clause (+6 lines) to disable memory reclamation under specific conditions, strictly adhering to user intent. CC proposed a more complex dynamic scheme (+63 lines), dynamically measuring memory pressure and adjusting reclamation thresholds.
• Architectural Analysis Reveals Foundational Differences: When problem-solving, CCA operates as a single agent, conducting exploration directly within the original context, maintaining awareness of the problem and past observations. CC employs a multi-agent architecture, delegating investigation tasks to independent, stateless sub-agents. These sub-agents, while instructed to be “thorough,” lack access to the main agent’s context, which can lead to over-complicated analysis or deviation from the core issue, and the main agent may over-trust the sub-agent’s suggestions.

Figure 5: Simplified execution traces for CCA and CC on PyTorch issue #161356. CCA explores within the main thread as a single agent, while CC delegates exploration to parallel, context-less sub-agents.

More Than a Research Prototype: A Production-Grade Toolchain for Developers

The Confucius SDK is designed to be a production-grade framework, offering a full suite of developer tools to support an agile agent development cycle:

• Trace UI: Visualizes call stacks, tool interactions, and memory flows for debugging and performance optimization.
• Playground: An interactive environment for prompt refinement and parameter tuning.
• Eval UI: Built-in support for regression tests, A/B comparisons, and benchmark evaluations.
• Centralized Agent Management: A unified interface for developing, integrating, deploying, and monitoring agents at scale.

Figure 6: CCA Trace UI, showing call stack visualization, latency metrics, token usage, and tool invocation details.

The Road Ahead: Towards an End-to-End Reinforcement Learning Framework

CCA’s design paves the way for more advanced training paradigms, particularly Reinforcement Learning (RL). Its AX framework already structures the agent’s internal reasoning traces in a trajectory-friendly format, making them directly suitable for RL training. The rich, fine-grained feedback signals generated by the Meta-Agent from tool extensions and environment interactions can be transformed into diverse reward functions.

Looking forward, CCA and the Confucius SDK have the potential to evolve into a platform that combines a production-grade SDK with a scalable trajectory collection and experimentation layer, supporting end-to-end RL on foundation models to learn more generalizable agentic capabilities.

Conclusion: A New Foundation for Transparent, Powerful, and Evolvable AI Engineering

The release of the Confucius Code Agent marks a significant leap forward for open-source AI software engineers towards industrial-grade capabilities. It is not merely an agent but an infrastructure built on a philosophy of explicitly balancing Agent Experience, User Experience, and Developer Experience, and it is transparent and reproducible.

Its experimental results demonstrate that the agentic framework—the orchestration, memory structures, and tool abstractions surrounding the model—is as important as, if not more so than, the raw model scale itself. Through hierarchical working memory, adaptive context compression, persistent note-taking, and modular extensions, CCA provides stable reasoning capabilities for long-horizon software engineering tasks.

More importantly, its open-source and modular architecture provides the community with a foundation for experimentation and innovation. Whether researching long-context reasoning, continual memory, exploring test-time adaptation, or integrating reinforcement learning, CCA offers a solid starting point. It holds promise for continuously bridging the gap between research prototypes and the demands of real-world software engineering, driving the development of more powerful, interpretable, safe, and continuously improving AI developers.

---

Frequently Asked Questions (FAQ)

Q: What’s the difference between Confucius Code Agent (CCA) and a regular code-generation LLM (like ChatGPT for Code)?
A: A regular code-generation LLM primarily generates code snippets based on your input prompt; it’s a passive tool. CCA is an active AI software engineer agent. It can autonomously operate within a complete code repository environment: locate files, read code, run commands, execute tests, analyze errors, and solve problems through multi-round iterative reasoning. It behaves more like a “programmer” with tools and continuous learning abilities.

Q: What exactly do AX, UX, and DX refer to? Why is this design so important?
A:

• AX (Agent Experience): Focuses on the agent’s internal “cognitive” experience. It needs concise, structured information (like compressed summaries, hierarchical memory) for effective reasoning, avoiding干扰 from human-readable verbose logs.
• UX (User Experience): Focuses on the human user’s experience. It needs transparency, interpretable execution traces, rich logs, and previews to build trust and a sense of control.
• DX (Developer Experience): Focuses on the agent developer’s experience. It requires the ability to observe the agent’s internal reasoning (AX) and external behavior (UX), along with modular interfaces for rapid iteration, debugging, and evaluation.
  Many frameworks conflate UX and AX, feeding human-oriented information directly to the AI, degrading both experiences. CCA explicitly separates these three, achieving optimal overall efficiency and quality.

Q: The “Note-Taking Agent” sounds abstract. What’s its practical use in programming?
A: Imagine CCA spends a long time debugging a complex concurrency bug for you, finally discovering it’s due to a boundary condition issue in a specific version of a library. The Note-Taking Agent would summarize this process (including the error stack, final solution, and underlying原理) into a structured Markdown note stored in a knowledge base. Next time, whenever you or CCA encounter a similar error message, the system can quickly retrieve this note and directly apply the known solution, saving massive amounts of重复 debugging time. This is “continuous learning” and “knowledge accumulation.”

Q: What does CCA’s performance data (e.g., 54.3%) mean? Is this level practical in real use?
A: The 54.3% Resolve@1 rate was achieved on the highly challenging, industrial-grade SWE-Bench-Pro benchmark, meaning it can independently and correctly solve over half of the real, complex GitHub issues on its first attempt. For context, the previous strongest open-source solutions were around 45-46%, and top closed-source solutions around 52%. This performance marks the first time an open-source AI programming assistant has matched or even surpassed顶尖 commercial tools in core capability. It already holds high practical value for automating大量重复性的、模式化的 coding tasks like fixing known bug types, dependency upgrades, or code style migrations.

Q: As an open-source project, how can I start using CCA or building on it for secondary development?
A: CCA is built on the Confucius SDK, which is highly modular. You can:

1. Use it directly: Deploy and run CCA as your personal or team’s AI programming assistant by following the project documentation.
2. Customize tools: Leverage the SDK’s extension system to write plugins for your company’s internal tools (e.g., specific build systems, deployment platforms, APIs), teaching CCA to use them.
3. Create new agents: Use the Meta Agent feature. Describe the specialized agent you need in natural language (e.g., “an agent focused on optimizing database queries”), and let the system automatically generate and optimize the configuration for you.
4. Conduct research: Its transparent architecture and rich trajectory data make it an excellent experimental platform for researching AI agent reasoning, memory, planning, and related topics.