Why pay for 50,000 tokens of agent history when only 3 facts are still true?

Because transcripts pile up obsolete tool outputs, superseded decisions, and dead turns. ContextGC deterministically garbage-collects your prompt in <3ms — slashing tokens by up to 66% and preserving active state without calling another model.

Open the console

TERMINAL pipeline_trace.json — airline_reservation_turn_6

39.6% smaller

What the agent was sent uncompiled transcript

:: system: You are an airline support agent.
> user: I need to change the cabin on reservation
>       0U4NPP. I am in economy class.
! assistant: Confirming reservation 0U4NPP.
!   <contextgc-state>{"assert":{"active_reservation":
!   "0U4NPP","cabin_class":"economy"}}</contextgc-state>
> user: Upgrade me to business class.
! assistant: Upgrading you now.
!   <contextgc-state>{"assert":{"cabin_class":
!   "business"}}</contextgc-state>
> user: Actually, keep it in economy, I changed
>       my mind.
  assistant: Reverting to economy.
> user: Thanks.
▌

What the model receives −39.6% tokens

:: [ACTIVE_AGENT_STATE]
    - active_reservation = "0U4NPP" (turn 2 [declared])
    - cabin_class = "economy" (turn 6 [declared])
:: system: You are an airline support agent.
  assistant: Confirming reservation 0U4NPP.
> user: Upgrade me to business class.
> user: Actually, keep it in economy, I changed
>       my mind.
  assistant: Reverting to economy.
> user: Thanks.
▌

The business upgrade is gone because the user reversed it, and the register states the value that survived. Nothing was inferred and nothing was invented — the agent said which key it had changed, as a side-effect of a turn it was already making.

The Problem

Why autonomous agents break down after 30 turns

As multi-turn dialogues grow, language models struggle with state conflict, payload bloat, attention loss, and provider cache eviction.

A user updates their delivery address or flight date 15 turns in. Later, when executing an action, the LLM hallucinates between both values in context or silently executes against the obsolete state.

Transcript Drift Trace State Collision

# Turn 3: User sets initial invariant
> user: Book flight to "SFO" on Oct 12.
# Turn 18: User updates their constraint
> user: Actually change that to "JFK" instead.
# Turn 28: LLM sees both turns, resurrects stale state
! error: Agent executed action with destination="SFO"

Bash command runs, SQL tables, and vector lookups dump hundreds of lines of raw tabular noise that no future turn ever reads again. Token bills explode, latency spikes, and attention evaporates.

Payload Growth Trace +340% Overhead

# Turn 8: Bash tool outputs verbose tabular trace
> tool_call: bash_run("git status && ls -la")
# Payload: 8,420 tokens dumped into context window
> tool_output: [8,402 irrelevant bytes retained]
# Turns 9-40: 99.8% of bytes never read again
! cost: $0.84 wasted per turn on dead payload

Critical user constraints and business invariants placed in the middle of a 40+ turn transcript suffer from U-shaped attention degradation. The LLM quietly ignores constraints without throwing an error.

Invariant Attenuation Trace Constraint Lost

# Turn 12: Business safety invariant declared
> system: "Always require supervisor approval before charging."
# Turn 35: Invariant enters middle-context blind spot
> attention: Attention weight falls to 0.12 (-78%)
# Turn 42: LLM bypasses invariant silently
! violation: Agent charged card directly without approval

Naive pruning or sliding-window truncation mutates early message boundaries on every turn. This breaks byte-identical prefixes, invalidating provider KV caches and driving TTFT to multi-second delays.

Prefix Mutation Trace Cache Eviction

# Turn 15: Sliding window prunes Turn 1-2 headers
> prefix: Byte-exact prefix stream mutated
# Provider prompt cache cannot match altered prefix
> kv_cache: CACHE MISS (Re-encoding 32k tokens)
> latency: TTFT spikes from 85ms to 2,420ms

The Architecture

The 4-stage context compilation pipeline

Each step is a pure, total mathematical function over the transcript. Zero model in the loop, zero stochastic drift, and identical input always yields identical output.

PIPELINE ACTIVE ContextGC · DAG Orchestrator

Capabilities

Engineered for safety, speed, and determinism

Everything required to operate production AI agents reliably across hundreds of turns.

DAG Engine 01

Deterministic State DAG

Mathematical tracking of entity lifecycles. When a key is re-asserted, the prior turn is retired; when a key is voided, it is cleanly struck from active state.

Safety Gate 02

Safety-First Compactor

Compresses multi-row tool payloads by up to 80% while guaranteeing that any row carrying allergen, PII, security, or expiry signals is strictly preserved.

Cache Align 03

KV-Cache Prefix Preserver

In cache_friendly mode, unchanged prefix messages are emitted byte-identical, retaining provider KV cache hits across model generations.

Dual Path I/O 04

Dual Read & Write Path

Extracts implicit facts using measured regex schemas on the read path, or receives direct declarations from the agent via <contextgc-state> blocks.

Evidence Gate 05

Lexical Evidence Gate

A turn is never retired if it remains the sole supporting evidence for an active fact. Orphaned assertions are mathematically prevented.

Pure Python 06

Zero-Dependency Core

Written in 100% pure standard-library Python (3.9–3.13). Installs instantly, needs no PyTorch or heavy NLP dependencies, and compiles in <3ms.

Empirical Evidence

Measured on 180 real agent trajectories

Not a benchmark of the compiler grading itself. Three public corpora, real model output, and a hand-labelled sample for the precision figure. Every number below ships with the n it came from.

Empirical Evidence · Paired Measures

Token Reduction vs. Compiler Precision

Grouped horizontal comparison across 3 distinct production agent domains on a unified 0–100% scale.

Token reduction

Compiler precision

MEASUREMENT BENCHMARK RATE (0 — 100%) VALUE

Coding 40 transcripts

SWE-agent bug-fixing, 20 repos · 161 turns retired · 668 payloads compacted

Token reduction

66.5%

Precision

100% n=36, CI 90–100%

Airline support 60 conversations

APIGen-MT-5k, reservation tool use · 9 turns retired · 138 payloads compacted

Token reduction

59.0%

Precision

100% n=72, CI 95–100%

Retail support 80 conversations

APIGen-MT-5k, order and exchange tool use · 2 turns retired · 275 payloads compacted

Token reduction

62.5%

Precision

100% n=47, CI 92–100%

0% 25% 50% 75% 100%

Reduction transfers across all three; supersession does not. Coding re-asserts a key 77 times across 40 transcripts, retail twice across 80 — so the two support corpora gain most of their reduction from compacting tool output, not from retiring turns. Reported separately because averaging them would hide it.

Specifications

Tech stack & integration architecture

Designed from first principles to be embedded in any Python agent runtime without friction.

Python 3.9 – 3.13

Pure standard library core. Zero third-party wheels, zero build tools, instantly installable.

Zero-dependency transcript compilation running at native CPython speeds with zero stochastic drift.

Runtime Footprint0 Dependencies

Compile Speed2.14ms Latency

Reliability100% Deterministic

ContextGC runs natively on Python 3.9 through 3.13 standard libraries using pure functional state transitions. Zero C extensions, zero binary wheels, and instant cold starts on AWS Lambda, Cloud Run, or minimal Alpine containers.

import contextgc

# Compiles multi-turn transcripts deterministically in <3ms:
result = contextgc.compile_transcript(
    transcript=history,
    schema="travel",
    mode="cache_friendly"
)
print(f"Saved {result.telemetry.compression_ratio_pct}% tokens in {result.telemetry.compile_time_ms}ms")

Framework Agnostic

Drop into LangChain, LangGraph, CrewAI, AutoGen, OpenAI Swarm, LlamaIndex, or raw API calls.

Seam-level context optimizer that fits seamlessly between any agent orchestrator and LLM provider.

EcosystemLangChain / LangGraph

Prompt CachePreserves KV Prefix

Wire FormatStandard OpenAI JSON

Transparent message interceptor: accepts standard OpenAI-compatible message arrays, compacts obsolete tool payloads, and retires superseded entity facts without breaking provider KV cache hits.

# Drop into any LangGraph node or CrewAI tool loop:
def context_cleaner_node(state):
    compiled = contextgc.compile_transcript(state["messages"])
    return {"messages": compiled.compiled_messages}

FastAPI / Uvicorn Server

Optional lightweight microservice layer with sub-3ms compile endpoints and CORS support.

High-throughput async REST API service for polyglot infrastructure, microservices, and distributed pipelines.

ThroughputAsync Non-blocking ASGI

PolyglotTypeScript, Go, Rust

Endpoints/api/compile, /api/schemas

Deploy as a standalone microservice or sidecar with CORS support. Perfect for polyglot production environments where TypeScript, Go, or Rust services need sub-3ms prompt garbage collection without embedding Python.

# Call ContextGC REST API from any language:
curl -X POST http://localhost:8914/api/compile \
  -H "Content-Type: application/json" \
  -d '{"schema": "travel", "transcript": [...]}'

Vanilla ESM Client

Modern browser frontend with zero build step, native CSS custom properties, and WCAG AA compliance.

Zero-build browser interface leveraging native ECMAScript modules, CSS tokens, and accessible reactive components.

Zero BundlerNo Webpack or Vite

AccessibilityWCAG 2.1 AA Audited

ThemingHardware Dark/Light

Built entirely with vanilla ECMAScript modules and native CSS custom properties. Zero build step, zero client bundle weight, and direct DOM streaming with WCAG 2.1 AA audited contrast ratios across all viewports.

// Direct browser fetch & streaming without bundler:
const res = await fetch("/api/compile", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ transcript, schema: "travel" })
});

Quick Start Integration

jaygopal@macbook:~/contextgc — bash

jaygopal:~$ pip install contextgc

✔ Preflight checks passed: pure Python 3.9+, 0 dependencies.

✔ Successfully installed contextgc-0.1.0

jaygopal:~$ python3 -m contextgc.compile --schema travel --mode cache_friendly transcript.json

✔ Loaded transcript: 14 turns (1,842 tokens)

✔ Invariants verified: refunds over 500 checked

✔ Compiled context: 7 turns (1,112 tokens, −39.6% reduction)

✔ Latency: 2.14ms | 0 LLM calls | 0 stochastic drift

jaygopal:~$ python3 run_agent.py

Reduced context by 39.6% in 2.14ms

from contextgc import compile_transcript

# Compile any multi-turn conversational transcript
result = compile_transcript(
    transcript=raw_messages,
    entity_schema="travel",       # or "coding", "logistics"
    mode="cache_friendly",        # preserves byte-identical KV prefix
    invariants=["refunds over 500 require human manager approval"]
)

# Pass the compiled context directly to your model
response = client.chat.completions.create(
    model="gpt-4o",
    messages=result.compiled_messages
)

print(f"Reduced context by {result.telemetry.compression_ratio_pct}% in {result.telemetry.compile_time_ms}ms")

Why pay for 50,000 tokens of agent history when only 3 facts are still true?

Why autonomous agents break down after 30 turns

Contradiction & Ghost State

Tool Payload Bloat & Token Bleed

Lost-in-the-Middle Decay

Prompt Cache Thrashing

The 4-stage context compilation pipeline

Engineered for safety, speed, and determinism

Deterministic State DAG

Safety-First Compactor

KV-Cache Prefix Preserver

Dual Read & Write Path

Lexical Evidence Gate

Zero-Dependency Core

Measured on 180 real agent trajectories

Token Reduction vs. Compiler Precision

Tech stack & integration architecture

Python 3.9 – 3.13

Framework Agnostic

FastAPI / Uvicorn Server

Vanilla ESM Client