The Bullet Protocol

The Bullet Protocol is a proposed specification for building reliable, reusable, and self-improving AI agent capabilities. It treats AI capabilities as granular, versioned, composable units that can be discovered, evaluated, and evolved systematically.

Building on Stanford's Agentic Context Engineering (ACE) framework (opens in a new tab), it addresses the core insight that agent context should be an evolving playbook of atomic knowledge pieces rather than compressed prompts that lose critical information over time.

The Problem

General purpose agents fail more often than they should, and not because language models aren't capable enough. The failures happen because of how we structure their capabilities.

Watch an agent work and you'll see the same problems repeat. It handles the common path perfectly, then hits an edge case and falls apart. It solves a problem beautifully one day, then makes the exact same mistake the next week. It works in testing, ships to production, and nobody can figure out what actually ran when things go wrong.

The core issue is context collapse. As agents work, their context gets compressed and rewritten to fit within token limits. Each compression loses nuance—subtle failure modes, hard-won operational knowledge, the specifics of why something works. The agent doesn't know what it's forgotten, so it can't ask for it back. Over time, the system gets less capable even as the underlying model improves.

There's also a pervasive brevity bias in how we write agent capabilities. We assume shorter is always better, so we strip out details. But language models work best with rich context that includes edge cases, examples, and rationale. By starving agents of information in the name of efficiency, we make them brittle.

And when something does break, there's no archaeology. Agent systems are black boxes. You can't rewind to see exactly which version of which capability ran, what guidance was active, or what decisions were made. Each agent deployment starts from scratch, rediscovering solutions others have already found, because there's no standard way to capture, version, and share what works.

The Proposal

The Bullet Protocol treats AI capabilities as a caching and accumulation problem. Once someone has figured out how to handle a task reliably, that solution should be reusable everywhere.

Every piece of knowledge is broken down into atomic units called bullets. Bullets are self-evaluating (tests embedded, not separate), versioned (semantic versioning with immutability), composable (through loose coupling), and discoverable (rich metadata enabling runtime search). The system generates execution manifests that serve as lockfiles, recording exactly which versions ran with what configurations.

This enables a self-improvement loop: agents attempt tasks, analyze outcomes, and evolve the bullet collection over time. Individual bullets evaluate themselves, but the ecosystem as a whole improves itself. Collective knowledge accumulates rather than being repeatedly lost.