OpenSage: Self-programming Agent Generation Engine

OpenSage is a novel Agent Development Kit that empowers LLMs to autonomously generate their own agent topologies, toolsets, and hierarchical memory structures, thereby outperforming existing human-dependent frameworks and advancing the shift toward AI-centered agent development.

The Gist

Imagine you are trying to build a team of robots to solve a complex problem, like fixing a broken spaceship or writing a new video game.

The Old Way (Current AI Tools):
Right now, building these robot teams is like hiring a human construction crew. You, the boss, have to draw the blueprints. You decide exactly how many robots you need, what tools each one gets (a hammer, a wrench, a computer), and how they talk to each other. If the job changes, you have to stop, erase the blueprints, and start over. It's slow, expensive, and if you forget to give a robot a screwdriver, the whole project fails. This is what current "Agent Development Kits" (ADKs) do: they give you the tools, but you have to design the team.

The New Way (OpenSage):
The paper introduces OpenSage, which is like handing the blueprints and the construction site to a Master Architect AI. Instead of you telling the AI what to do, you just say, "Build me a team to fix this spaceship."

OpenSage is the first system that lets the AI program itself. It doesn't just follow orders; it builds its own team, invents its own tools, and remembers everything it learns.

Here is how OpenSage works, broken down into three simple parts:

1. The Self-Organizing Team (Agent Topology)

• The Analogy: Imagine a general in a war room. In the old way, the general had to call specific, pre-named lieutenants. In OpenSage, the general can look at the battlefield and say, "I need a sniper team here and a medic team there," and the system instantly creates those teams on the fly.
• How it works: The AI can create "sub-agents" (little helper robots) whenever it needs them.
  • Vertical Team: It breaks a big job into small steps and assigns a different robot to each step (like a factory assembly line).
  • Horizontal Team: It can hire five different robots to solve the same problem at the same time, then pick the best answer (like a panel of judges).
  • The Magic: The AI decides who to hire and when to fire them, without you touching a single line of code.

2. The Magic Toolbox (Dynamic Tool Synthesis)

• The Analogy: Usually, if a robot needs a specific tool (like a "space-wrench"), and you didn't pack one, the robot is stuck. With OpenSage, if the robot needs a space-wrench, it 3D prints one right there in the moment.
• How it works:
  • Writing Tools: If the AI needs to do something specific (like analyze a computer virus), it writes its own software tool to do it.
  • Safe Sandbox: Imagine these new tools are built in their own little glass bubbles (containers). If a tool crashes or has a virus, it only breaks the bubble, not the whole system.
  • Specialized Kits: It comes with a pre-loaded "Software Engineering Kit" that knows how to fix code, debug programs, and run tests, which other systems can't do as easily.

3. The Super-Brain Memory (Hierarchical Memory)

• The Analogy: Most robots have a short-term memory (like a sticky note) and a long-term memory (a messy filing cabinet). If the note gets too full, they forget things. OpenSage gives the robot a living, breathing library.
• How it works:
  • Short-Term: It keeps a graph (a web of connections) of what happened right now.
  • Long-Term: It saves the "big ideas" and "lessons learned" in a structured database.
  • The Librarian: There is a special "Memory Agent" (a librarian robot) that organizes this library. It doesn't just dump data; it connects the dots. If you ask, "How did we fix that bug last week?" it finds the exact page, the code, and the solution, rather than just showing you a list of words that sound similar.

Why Does This Matter?

The researchers tested OpenSage on three very hard challenges:

1. CyberGym: Finding security holes in code.
2. Terminal-Bench: Solving complex computer terminal tasks.
3. SWE-Bench: Fixing real-world software bugs.

The Result: The AI teams built by OpenSage crushed the competition. They solved problems that other systems couldn't even touch.

• In one test, OpenSage solved 60% of security problems, while the next best system only solved 39%.
• In software fixing, OpenSage solved 59% of bugs, while the next best only solved 40%.

The Big Picture

The paper argues that we are shifting from a "Human-Centered" world (where humans build the robots) to an "AI-Centered" world (where AI builds its own robots).

Think of it like the evolution of cars:

• Old ADKs: You have to build the engine, the wheels, and the steering wheel yourself.
• OpenSage: You get a self-driving car that can build its own engine and wheels if it realizes it needs a faster one.

This isn't just about making AI smarter; it's about giving AI the freedom to evolve. It's the first step toward a future where AI doesn't just answer questions, but builds the entire team and toolkit needed to solve the problem on its own.

Technical Summary

1. Problem Statement

Current Agent Development Kits (ADKs) such as LangChain, OpenHands, and Google ADK rely on a human-centered paradigm. In these systems, human developers must manually design three critical architectural components:

1. Agent Topology: The structure, dependencies, and interaction mechanisms between agents.
2. Tooling Systems: The specific tools and APIs available to the agent.
3. Memory Systems: How agents store and retrieve past interactions and knowledge.

Limitations of Current Approaches:

• Lack of Scalability: Manual design requires significant domain expertise and effort, limiting the ability to scale agent construction.
• Poor Generalizability: Static structures cannot dynamically adapt to new tasks. A parent agent is often restricted to pre-defined sub-agents and cannot create new ones on the fly.
• Tool Constraints: Existing ADKs struggle with heterogeneous tool requirements (e.g., conflicting dependencies) and lack support for AI-generated tools.
• Memory Inefficiency: Current memory systems often rely on linear lists or simple embeddings, failing to capture complex relationships or manage long-horizon tasks effectively.

The paper argues that the field needs to shift to an AI-centered paradigm, where the AI itself constructs its own agent structures, tools, and memory, similar to how modern ML models learn representations directly from data rather than relying on hand-crafted features.

2. Methodology: OpenSage Framework

OpenSage is the first ADK designed to enable LLMs to autonomously generate agent topologies, synthesize tools, and manage memory. It consists of three core technical pillars:

A. Self-Generating Agent Topology

OpenSage allows a "Parent Agent" to dynamically create, manage, and terminate "Sub-Agents" at runtime.

• Creation Mechanism: The parent agent generates a configuration file (metadata) specifying the sub-agent's model, system instructions, and tools. OpenSage parses this to instantiate a Python object and store it in a unified Sub-Agent Pool.
• Topological Flexibility:
  • Vertical Topology: Decomposes complex tasks into sequential sub-tasks handled by specialized sub-agents (e.g., a debugging agent). This isolates context to prevent overflow.
  • Horizontal Topology (Ensemble): Multiple sub-agents execute the same task with distinct plans simultaneously. Their results are merged via an ensemble mechanism.
• Management: Includes tools for searching, cloning, and resuming sub-agents. It supports inter-agent communication via a shared message board to synchronize parallel tasks.

B. Dynamic Tool Synthesis

OpenSage moves beyond static tool APIs to allow agents to write, register, and manage their own tools.

• Hierarchical Structure: Tools are organized as a file-system hierarchy (modules/scripts) with metadata. Agents can discover tools by narrowing down categories before inspecting specific implementations.
• Meta-Tools: A set of "meta-tools" allows agents to write new tools (e.g., generating Bash scripts or Python modules) which are then validated and registered.
• Runtime Management:
  • Containerized Sandboxing: Each tool set runs in an isolated Docker container with specific dependencies, preventing conflicts.
  • State Persistence: Container snapshots are saved as Docker layers to reuse environments, reducing startup time.
  • Asynchronous Execution: Long-running tools (e.g., static analysis) run in the background, with agents polling for status.
• Domain-Specific Toolkit: Includes specialized tools for software engineering (static/dynamic analysis, fuzzing) that existing ADKs cannot support due to environment constraints.

C. Hierarchical Memory Management

OpenSage implements a graph-based memory system managed by a dedicated Memory Agent.

• Short-Term Memory: A graph structure tracking the execution history of the current task. It uses AgentRun nodes for agents and Event nodes for tool calls/responses. Long outputs are summarized, and older history is compressed.
• Long-Term Memory: A Neo4j graph database storing shareable, high-level knowledge (e.g., code structures, user queries) across tasks. It uses explicit node types (e.g., Class, Function) and edges to represent relationships.
• Memory Agent: An abstraction that handles read/write operations. It decides whether to query short-term or long-term memory, performs retrieval (using both graph traversal and embedding similarity), and manages updates to ensure only non-redundant knowledge is persisted.

3. Key Contributions

1. First AI-Centered ADK: OpenSage pioneers the shift from human-designed agent structures to AI-generated topologies, tools, and memory.
2. Dynamic Agent Lifecycle: Introduces a mechanism for runtime creation and management of sub-agents, enabling both vertical decomposition and horizontal ensembles.
3. Self-Programming Tooling: Enables agents to synthesize new tools dynamically and manage them in isolated, heterogeneous environments.
4. Graph-Based Hierarchical Memory: Combines short-term execution graphs with long-term knowledge graphs, managed by an AI agent to optimize context length and retrieval relevance.
5. Comprehensive Evaluation: Validates the system across three diverse benchmarks (CyberGym, Terminal-Bench 2.0, SWE-Bench Pro) and various backbone models.

4. Experimental Results

The authors evaluated OpenSage (using "SageAgent") against state-of-the-art agents and ADKs (e.g., Claude Code, OpenHands, SWE-agent) on three benchmarks:

• CyberGym (Security Vulnerabilities):
  • Result: SageAgent achieved a 60.2% resolved rate, outperforming the next best (Anthropic Agent at 50.6%) and OpenHands (39.4%).
  • Ablation: Disabling the agent ensemble (NoHorizontal) or vertical topology (NoVertical) caused significant performance drops, proving the necessity of dynamic structure.
• Terminal-Bench 2.0 (General Terminal Tasks):
  • Result: SageAgent achieved 78.4%, surpassing Droid (77.3%) and Simple Codex (75.1%) using the same backbone model (GPT-5.3-Codex).
  • Cost Efficiency: A "Large-Small" collaboration (Gemini 3 Pro planning + GPT-5 Mini execution) matched the performance of a single strong model (GPT-5) but at a significantly lower cost.
• SWE-Bench Pro (Software Engineering):
  • Result: SageAgent achieved 59.0%, significantly beating SWE-agent (40.2%) and Agentless (9.4%).
  • Memory Impact: Ablation studies showed that removing the hierarchical memory design dropped performance to 56.2%, while using a non-AI graph memory (Mem0g) offered negligible improvement over having no memory. This highlights the importance of AI-driven memory management.

Key Observation: OpenSage agents actively created specialized sub-agents (e.g., debuggers) and task-specific tools (e.g., fuzzers) during execution, behaviors not seen in static ADKs.

5. Significance and Future Work

• Paradigm Shift: OpenSage demonstrates that AI can autonomously design its own operational framework, moving the field from "feature engineering" to "self-evolving agents."
• Scalability: By automating the design of topology and tools, OpenSage lowers the barrier for building complex, robust agentic systems.
• Future Directions:
  • Extending support for AI-generated workflows (defining dependencies and communication protocols).
  • Integrating model training support (e.g., via AReaL, verl) to train agents specifically on real-world tasks using OpenSage's sandbox infrastructure.
  • Enhancing safety and auditing mechanisms for self-programming agents.

In conclusion, OpenSage provides a foundational framework for the next generation of AI agents, proving that self-programming capabilities significantly enhance performance, adaptability, and cost-efficiency in complex, real-world tasks.