OpenSage: Next Generation of Agentic AI

TL;DR

• The problem: today you design the whole system before you build the agent — topology, toolset, and memory structure are all pre-specified. But on complex long-horizon jobs an agent needs to spawn sub-agents mid-run and often discovers its given tools aren't enough. Freezing all of that upfront caps generalizability.
• The analogy: this is feature engineering circa 2006–2016 — injecting human inductive bias and shrinking the model's search space. Deep learning's answer was to feed raw data and let the model figure it out. OpenSage does the same for agents: ship a minimal scaffold and let AI build the agent.
• Results: at release (~February 2026) OpenSage beat Claude Code and Codex on coding and security benchmarks; more striking, it was run against the DEF CON 2026 qualifiers — 7 of 15 non-interactive challenges solved, 8 flags total, good enough for a top-five finish among all teams that ever played, and it beat every team claiming no or low AI use.
• What's next: building the agent is step one; the model has to co-evolve with it. Even the latest models haven't fully learned to build their own agents (they try to spawn sub-agents and fail), so the work now spans the framework, model training, and an inference stack designed for agent trajectories.

Key Points

The ceiling of agent 1.0: everything is decided upfront (~00:04–00:06)

Guo opened with how agents get built today: the agent structure, topology, toolset, and memory structure are all fixed before any code runs — "it's like you build a software, you know exactly what you want to build, you have a clear system design, and then we let the agent run the job."

That breaks down on long-horizon work. Mid-execution an agent may need to spawn its own sub-agent, or realize the tools it was handed aren't sufficient and that it needs to invent new ones. If all of that is pre-specified, you have constrained the agent's capability and generalizability.

From feature engineering to agent 2.0 (~00:06–00:08)

The framing comes from ML history. Ten or twenty years ago, step one in building a model was feature engineering — extracting features from raw inputs, which really means baking human knowledge, or inductive bias, into the model. Then the field discovered that step was unnecessary: train a deep network on raw data and it figures the features out itself, and without the inductive-bias constraint it searches a much larger space for better solutions.

OpenSage asks the same question about agents. Skip the manual feature engineering — the pre-specified workflow, topology, and toolset — and instead build a minimal scaffold that lets the agent build its own agent: give it some initial tools, and let it spawn sub-agents, design its own workflow topology, write its own tools, and even design its own memory along the way.

Concretely, they redesigned the whole ADK (agent development kit) so the agent can explore its own topology and author its own tools during execution. A comparison slide put OpenSage against Google's and other frontier ADKs on exactly these capabilities — and because no existing ADK offers that freedom, they call it agent 2.0, with today's frameworks as agent 1.0.

Evidence: benchmarks and DEF CON (~00:09–00:12)

• Benchmarks: evaluated mainly on coding plus several security benchmarks. At release (~February this year) it outperformed all existing agent frameworks against Claude Code and Codex on SWE-bench, SWE-bench Pro, and others. He noted the numbers are already dated — OpenSage keeps evolving.
• DEF CON 2026 qualifiers: he described it as the Olympics of offensive security, normally requiring a team of professional hackers working 48 hours, sometimes hundreds of them. Since the organizers don't allow AI submissions, the team ran in parallel with the live competition. Of 15 non-interactive challenges, it solved 7; post-hoc analysis showed 4 more were close enough that another hour might have cracked them. 8 flags total — enough for a top-five placing among all teams that have ever competed, and enough to beat every team that claimed no or low AI usage.
• The behavior in the traces is the real point: OpenSage ran five to six hours continuously and spawned thousands of sub-agents to get there, demonstrating that it genuinely scales its own topology to task difficulty.

Closing: the model has to co-evolve (~00:12–00:13)

The agent is only the first step; the brain matters too. Their observation running OpenSage on the latest models is that the model hasn't fully figured out how to build its own agent — it tries to spawn a new agent and the attempt fails.

That pushes them toward an end-to-end picture: use new agents to train the model, train the model to spawn its own agents and write its own tools better, and — because agent trajectories look nothing like pure QA tasks — build new agent inference frameworks as well.

The closing message: the future of AI agents is about opening up the freedom for AI to explore everything that ultimately constitutes the agent. What humans should supply is meaningful scaffolding, a powerful model, and the most efficient inference framework.

Quotes

"What about we just build a minimal set of scaffold that enable the agent to build its own agent?" (~00:07)

The whole design philosophy in one sentence.

"We want something like AI build AI — agent build agents." (~00:07)

"This is the AI-only agent that's able to beat a team of professional hackers that didn't use AI in their competition." (~00:11)

The DEF CON headline.