How It Works
Raw signals in. Compounding intelligence out. Each layer compresses, verifies, and routes — building an architecture that gets smarter with every session.
The model is the pen. The structure is the brain.
01 — Capture
Every debugging session, every architectural decision, every workaround — captured silently in the background. No tagging. No note-taking. You just work.
You solved it once. That should be enough.
02 — Synthesis
Raw session data is noise. ACE compresses it — extracting the discoveries, decisions, and patterns that actually matter. What took you an hour to figure out becomes a single retrievable insight.
03 — Knowledge
Not everything makes it. Observations are scored, deduplicated, and verified before they become permanent knowledge. Outdated patterns get flagged. Contradictions get surfaced. Only what's proven survives.
Your AI doesn't just remember — it knows what to trust.
04 — Intelligence
When any agent hits a problem, ACE surfaces knowledge from every prior session — including solutions found by different agents, in different contexts, days ago. The hour you spent debugging? Every future session skips it entirely.
Stop re-explaining your codebase. It already knows.
05 — Evolution
Between sessions, ACE consolidates what it's learned — reinforcing patterns that held up, retiring knowledge that didn't, and identifying gaps it should research next. You didn't do anything. It just got better.
The intelligence curve only goes up.
Inside the capture layer
Every tool call — file reads, terminal commands, search queries, edits — is intercepted before it reaches the model. The capture layer extracts file paths, classifies output types, detects error patterns, and timestamps everything. The raw session becomes structured data.
Inside the synthesis layer
A fast classifier reads the raw event stream and extracts typed observations — each with a category, confidence score, and evidence polarity. Thousands of tokens of tool output compress into structured knowledge. The compression ratio is roughly 16:1.
Bash: pytest tests/ → 3 failed
FAILED test_config_timeout[30s] - TimeoutError
FAILED test_config_timeout[60s] - TimeoutError
FAILED test_config_retry[default] - ConnectionResetError
Default timeout of 30s insufficient for integration tests
Tests requiring external API calls fail at 30s and 60s. Setting timeout to 120s resolves all 3 failures. Root cause: upstream service latency under load.
confidence: 0.82 · polarity: positive · files: shared/config.py
Inside the knowledge layer
Not every observation deserves to persist. The graduation pipeline filters through confidence gates, deduplicates against existing knowledge, and promotes only what meets the bar. 98.6% of raw events are noise. The pipeline finds the signal.
Inside the intelligence layer
An agent hits a 401 error debugging an API integration. Instead of re-tracing the full authentication cascade, the retrieval engine surfaces a diagnosis from three days ago — by a different agent, in a different session. The fix was already learned.
Negative knowledge is the most valuable kind. The system remembers what didn't work — so the same mistake never recurs across any agent.
OAuth token not usable as direct API key
Subscription OAuth token (claudeAiOauth.accessToken) returns 401 when passed as x-api-key. Must use CLI bridge for auth.
Auth cascade: env → .env file → CLI credentials
Centralized in auth_resolver.py. All components use resolve_auth() + build_cli_subprocess_env().
Inside the evolution layer
Between sessions, the consolidation infrastructure reviews high-salience observations against existing knowledge. What held up gets reinforced. Contradictions get flagged. Gaps in coverage trigger targeted research. The system is designed to maintain itself — so every session starts with better context than the last.
Five layers of compression, verification, and routing — building an architecture that compounds.