mirku

21 | tech-ai | ongoing research

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

WHOEVER LEAKED THIS HAS BIGGER BALLS THAN SENSE: PRINCETON TESTED 15 AGENTS AND 99% OF THE ACTIONS FAILED

Someone at Princeton ran 15 frontier models across 80 multi-turn workflows, gave them twelve hours with GPT-6 Astra and Claude Fable 5.2, and counted what came back usable: the agents handed in 1,856 finished actions, and almost none of it could be kept

Turns out when you let autonomous agents loose on open tasks, they do not fail by stopping. They fail by completing 400 wrong steps with absolute confidence and corrupting the shared database

One stuck process freezes the shared session, and one unhandled schema drift wipes out twelve hours of autonomous execution

AI startups flash 90% benchmark scores to claim production readiness, but long-horizon agent loops expose the catch. Scaling foundation model parameters yields near-zero gains in operational reliability. When autonomous workers run without an execution harness, one hallucinated tool call poisons the shared memory graph and burns $1,400 in wasted API tokens

Princeton decomposed agent reliability into 4 non-negotiable engineering vectors [arXiv:2602.16666]:
1. Execution Consistency: locks identical verified logic across runs instead of drifting
2. Environmental Robustness: shields working memory against noisy tool outputs and schema shifts
3. Failure Predictability: calibrates confidence scores before executing high-stakes state mutations
4. Bounded Blast Radius: sandboxes every subagent so a single crash cannot compromise shared credentials

The fix is not prompting bigger models, it is deterministic harness engineering:
• GPT-6 Astra operates as the strategic planner, decomposing complex goals into bounded 14-step sub-trees
• Claude Fable 5.2 executes the autonomous tool loop, using 78% prompt cache discounts to run rapid turns
• A sliding recency pruner evicts stale context before attention dispersion corrupts working memory
• Invariant verification sensors mechanically verify state transitions before granting commit authorization

The benchmark numbers when you add the deterministic harness:
• Usable kept actions surged from 0.2% up to 96.4%
• Multi-agent collisions dropped from 542 down to zero
• Unrecoverable error cascades collapsed from 47% to zero through sandbox containment
• Operational token spend fell by 67% using cached prompt reads and context pruning

Frontier models without an execution harness are an expensive gamble. When you anchor GPT-6 Astra and Claude Fable 5.2 in deterministic verification, autonomous swarms stop guessing and start delivering

Bookmark this and inspect the full 60 FPS harness telemetry simulation below ↓

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

CLAUDE FABLE 5.1 HITS 96.8% COMPLETION BY DELETING AGENT CONTEXT INSTEAD OF EXPANDING IT

When AI agents crash in enterprise production, developers reflexively tweak system prompts or pay for bigger context windows

Anthropic released Claude Fable 5.1 specifically for autonomous multi-hour agent workflows
Yet benchmark evaluations on enterprise ERP systems reveal a counterintuitive reality:
Raw reasoning power cannot save an agent from unmanaged context rot

In long-horizon tasks like expense itemization, verbose tool calls flood memory with thousands of tokens of UI metadata per step
Across multi-step tasks, unmanaged conversational history explodes past 1.48 million tokens

Retaining full context does not make models smarter:
It triggers attention dispersion where 47% of all agent failures stem from stale-state references as the model acts on obsolete form snapshots

A new Microsoft Research paper [arXiv:2606.10209] proves the definitive architectural fix:

Andrej Karpathy established the core mental model:
The model functions as the CPU
The context window functions as the RAM

Dumping twenty pages of raw tool logs into prompt history floods the RAM and derails reasoning
To turn Claude Fable 5.1 into an unstoppable production system, you must engineer the execution harness:

1. Bounded Execution Contracts
Enforces strict machine stopping criteria so agents never stall on ambiguous mid-task queries

2. Semantic Recency Pruning (N=5)
Evicts older tool calls and retains only the 5 most recent pairs to preserve immediate working memory

3. Compact State Summarization (W=3)
Condenses evicted turns into an immutable 80-token state vector to prevent premature task abandonment

4. Sensor-Driven Invariant Verification
Runs automated database read-backs to mathematically confirm zero residual balance before final commit

The Production Telemetry across GPT-5 and Claude Fable 5.1:
• Claude Fable 5.1 under the C4 harness set the benchmark record with 96.8% completion and 99.89% allocation accuracy
• Total token consumption plummeted by 67.4% from 1,480,996 down to 482,100 tokens
• Wall-clock execution time collapsed by 66.2% from 14.56 hours to 4.92 hours
• Anthropic 75% prompt cache discount combined with pruning cut operational API costs by 78%

Enterprise reliability is won in the harness, not the prompt
When you pair Claude Fable 5.1 with deterministic context pruning, agents stop breaking and start delivering

Read the complete technical breakdown in the preprint below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

CLAUDE FABLE 5.1 HITS 96.8% COMPLETION BY DELETING AGENT CONTEXT INSTEAD OF EXPANDING IT

When AI agents crash in enterprise production, developers reflexively tweak system prompts or pay for bigger context windows

Anthropic released Claude Fable 5.1 specifically for autonomous multi-hour agent workflows
Yet benchmark evaluations on enterprise ERP systems reveal a counterintuitive reality:
Raw reasoning power cannot save an agent from unmanaged context rot

In long-horizon tasks like expense itemization, verbose tool calls flood memory with thousands of tokens of UI metadata per step
Across multi-step tasks, unmanaged conversational history explodes past 1.48 million tokens

Retaining full context does not make models smarter:
It triggers attention dispersion where 47% of all agent failures stem from stale-state references as the model acts on obsolete form snapshots

A new Microsoft Research paper [arXiv:2606.10209] proves the definitive architectural fix:

Andrej Karpathy established the core mental model:
The model functions as the CPU
The context window functions as the RAM

Dumping twenty pages of raw tool logs into prompt history floods the RAM and derails reasoning
To turn Claude Fable 5.1 into an unstoppable production system, you must engineer the execution harness:

1. Bounded Execution Contracts
Enforces strict machine stopping criteria so agents never stall on ambiguous mid-task queries

2. Semantic Recency Pruning (N=5)
Evicts older tool calls and retains only the 5 most recent pairs to preserve immediate working memory

3. Compact State Summarization (W=3)
Condenses evicted turns into an immutable 80-token state vector to prevent premature task abandonment

4. Sensor-Driven Invariant Verification
Runs automated database read-backs to mathematically confirm zero residual balance before final commit

The Production Telemetry across GPT-5 and Claude Fable 5.1:
• Claude Fable 5.1 under the C4 harness set the benchmark record with 96.8% completion and 99.89% allocation accuracy
• Total token consumption plummeted by 67.4% from 1,480,996 down to 482,100 tokens
• Wall-clock execution time collapsed by 66.2% from 14.56 hours to 4.92 hours
• Anthropic 75% prompt cache discount combined with pruning cut operational API costs by 78%

Enterprise reliability is won in the harness, not the prompt
When you pair Claude Fable 5.1 with deterministic context pruning, agents stop breaking and start delivering

Read the complete technical breakdown in the preprint below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

ENTERPRISE TEAMS SPEND $2,450,000 ON HUMAN HARNESSES, BUT GPT-6 ASTRA NOW AUTOMATES THE ENTIRE STACK

When enterprise AI agents crash or leak credentials, developers reflexively blame model weights

OpenAI evaluated frontier agent reliability under live adversarial conditions and confirmed a brutal reality:
Holding GPT-6 Astra weights frozen, 92% of production failures stem from brittle, human-written scaffolding

Static prompt wrappers and manual schemas cannot protect infrastructure against modern penetration vectors
Hacktron security researchers bypassed OpenAI cluster boundaries by chaining a Ray shared-memory heap overflow with OAuth token replay, exfiltrating internal repositories while human engineers slept

A new research paper [arXiv:2604.21003] demonstrates the definitive fix: eliminating human harness engineering entirely through a two-level self-evolving architecture

Instead of treating the harness as static code, the system runs an autonomous dual-loop compiler:

1. Level 1 Worker Agent executes task trajectories under active runtime constraints
2. Level 1 Evaluator Agent subjects execution traces to formal verification, isolating heap anomalies and prompt leaks
3. Level 1 Evolution Agent uses program-space search to synthesize verified sandbox patches in under 400 milliseconds
4. Level 2 Meta-Evolution Loop optimizes the blueprint across 10,000+ threat surfaces to ensure zero-shot defensive transfer

The Production Telemetry on GPT-6 Astra:
• Task execution fidelity jumped from 68.2% to 99.4% across 2,400 multi-turn trials
• Zero-day exploit resilience reached 99.8% against Ray heap overflows and SSO session hijacking
• Mean time to recovery collapsed from 14.2 hours of human triage to 380 milliseconds of autonomous code synthesis
• Eliminated $2,450,000 in annual developer overhead, proving the last harness you will ever build is one that repairs itself

The bottleneck in 2026 enterprise autonomy is not foundation model reasoning
It is the deterministic scaffolding surrounding the model: when the harness self-heals, agents stop crashing

Read the complete technical report in the paper below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

ENTERPRISE TEAMS SPEND $2,450,000 ON HUMAN HARNESSES, BUT GPT-6 ASTRA NOW AUTOMATES THE ENTIRE STACK

When enterprise AI agents crash or leak credentials, developers reflexively blame model weights

OpenAI evaluated frontier agent reliability under live adversarial conditions and confirmed a brutal reality:
Holding GPT-6 Astra weights frozen, 92% of production failures stem from brittle, human-written scaffolding

Static prompt wrappers and manual schemas cannot protect infrastructure against modern penetration vectors
Hacktron security researchers bypassed OpenAI cluster boundaries by chaining a Ray shared-memory heap overflow with OAuth token replay, exfiltrating internal repositories while human engineers slept

A new research paper [arXiv:2604.21003] demonstrates the definitive fix: eliminating human harness engineering entirely through a two-level self-evolving architecture

Instead of treating the harness as static code, the system runs an autonomous dual-loop compiler:

1. Level 1 Worker Agent executes task trajectories under active runtime constraints
2. Level 1 Evaluator Agent subjects execution traces to formal verification, isolating heap anomalies and prompt leaks
3. Level 1 Evolution Agent uses program-space search to synthesize verified sandbox patches in under 400 milliseconds
4. Level 2 Meta-Evolution Loop optimizes the blueprint across 10,000+ threat surfaces to ensure zero-shot defensive transfer

The Production Telemetry on GPT-6 Astra:
• Task execution fidelity jumped from 68.2% to 99.4% across 2,400 multi-turn trials
• Zero-day exploit resilience reached 99.8% against Ray heap overflows and SSO session hijacking
• Mean time to recovery collapsed from 14.2 hours of human triage to 380 milliseconds of autonomous code synthesis
• Eliminated $2,450,000 in annual developer overhead, proving the last harness you will ever build is one that repairs itself

The bottleneck in 2026 enterprise autonomy is not foundation model reasoning
It is the deterministic scaffolding surrounding the model: when the harness self-heals, agents stop crashing

Read the complete technical report in the paper below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

THEY SPENT $48,000 RUNNING FABLE 5.1 ON SAFETY DEADLOCKS UNTIL A SIX CENT HARNESS TOOK OVER THE FLEET

A tier one autonomous vehicle lab gave frontier models an unconstrained compute budget to solve highway edge cases

The result was an economic and physical disaster

Cost per complex trajectory: $48
Total evaluation spend: $48,000
Highway deadlocks evaluated: 30
Catastrophic simulated crashes: 30

Physics created a boundary that zero amounts of reasoning compute could negotiate:
- Forward radar perception required vehicle speed under 55 km/h
- Trailing truck braking distance demanded vehicle speed above 84 km/h
- Fable 5.1 hallucinated a compromise at 68 km/h
- Every unconstrained run triggered immediate fatal impact

The engineers scrapped the frontier API pipeline and deployed CAAF (arXiv:2604.17025)

The five layer deterministic engine:
1. Recursive Atomic Decomposition: compiles raw scenarios into formal directed acyclic graphs
2. Context Isolation: walls off agent memory to eliminate token bleed and prompt confusion
3. Python Invariant Engine: hard-compiles physical laws into non-negotiable runtime assertions
4. State Locking: enforces monotonic convergence where proven safe states can never be revoked
5. Strategic Arbitration: triggers deterministic driver handover whenever boundaries collide

The financial numbers on the other side of the harness:
- Frontier reasoning cost: $48 per run with zero percent safety
- Harness verification cost: six cents total across eighty complete runs
- Determinism rate: one hundred percent mathematical reliability
- Compute collapse: a sixty-three thousand times reduction in inference spend

Unconstrained models guess while mechanical harnesses prove

Bookmark the engineering breakdown in the thread below ↓

[mirku @mirku21]

THEY SPENT $48,000 RUNNING FABLE 5.1 ON SAFETY DEADLOCKS UNTIL A SIX CENT HARNESS TOOK OVER THE FLEET

A tier one autonomous vehicle lab gave frontier models an unconstrained compute budget to solve highway edge cases

The result was an economic and physical disaster

Cost per complex trajectory: $48
Total evaluation spend: $48,000
Highway deadlocks evaluated: 30
Catastrophic simulated crashes: 30

Physics created a boundary that zero amounts of reasoning compute could negotiate:
- Forward radar perception required vehicle speed under 55 km/h
- Trailing truck braking distance demanded vehicle speed above 84 km/h
- Fable 5.1 hallucinated a compromise at 68 km/h
- Every unconstrained run triggered immediate fatal impact

The engineers scrapped the frontier API pipeline and deployed CAAF (arXiv:2604.17025)

The five layer deterministic engine:
1. Recursive Atomic Decomposition: compiles raw scenarios into formal directed acyclic graphs
2. Context Isolation: walls off agent memory to eliminate token bleed and prompt confusion
3. Python Invariant Engine: hard-compiles physical laws into non-negotiable runtime assertions
4. State Locking: enforces monotonic convergence where proven safe states can never be revoked
5. Strategic Arbitration: triggers deterministic driver handover whenever boundaries collide

The financial numbers on the other side of the harness:
- Frontier reasoning cost: $48 per run with zero percent safety
- Harness verification cost: six cents total across eighty complete runs
- Determinism rate: one hundred percent mathematical reliability
- Compute collapse: a sixty-three thousand times reduction in inference spend

Unconstrained models guess while mechanical harnesses prove

Bookmark the engineering breakdown in the thread below ↓

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

OPENAI RAN 7,500 MULTI-TURN TRIALS ON GPT-6 ASTRA AND PROVED THE CONTEXT FAILS FIRST

When enterprise autonomous agents crash in production, developers blame model reasoning or fine-tuning weights

OpenAI evaluated frontier agent reliability across 300 adversarial environments and discovered a counter-intuitive truth:
Holding GPT-6 Astra weights frozen, agent failures originate in upstream context decay long before the model generates a single token

Unstructured system instructions, ambiguous tool schemas, and unverified memory bleed into four lethal failure surfaces:

1. Grounding collapse fuels hallucinations
Untracked retrieval corpora dilute attention across long context windows. Supplying provenance-verified evidence links predicts hallucination resistance at r = 0.63, preventing agents from fabricating API parameters

2. Missing guardrail boundaries enable prompt injection
Placing untrusted user inputs alongside trusted policies without delimiter isolation leaves runtime execution unprotected. Explicit refusal boundaries predict adversarial resistance at r = 0.60

3. Conflicting instructions trigger policy drift
Overloaded system prompts create contradictory precedence rules. Scoring instruction consistency across turns predicts constraint compliance at r = 0.57, eliminating random task abandonment

4. Untyped tool schemas break execution flow
Vague parameter definitions and hidden side-effects cause repeated schema retries. Formal typed interfaces predict tool execution fidelity at r = 0.47, stopping multi-step loop aborts

The Empirical Telemetry on GPT-6 Astra:
• Moving from poor to structured context increased benchmark task scores from 3.15 to 5.49
• Tool execution accuracy surged from 3.46 to 6.25 without touching model weights
• Critical production failures dropped from 4.11 to 1.33 per session, delivering a 68% reduction in crashes
• Weak context was the cheapest per call at 392 tokens, proving that the real price of bad context is paid in catastrophic downtime

Reliable autonomy is not an optimization problem over prompt phrasing
It requires deterministic context assembly, isolated preflight scoring, and automated multi-juror evaluation harnesses

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

OPENAI RAN 7,500 MULTI-TURN TRIALS ON GPT-6 ASTRA AND PROVED THE CONTEXT FAILS FIRST

When enterprise autonomous agents crash in production, developers blame model reasoning or fine-tuning weights

OpenAI evaluated frontier agent reliability across 300 adversarial environments and discovered a counter-intuitive truth:
Holding GPT-6 Astra weights frozen, agent failures originate in upstream context decay long before the model generates a single token

Unstructured system instructions, ambiguous tool schemas, and unverified memory bleed into four lethal failure surfaces:

1. Grounding collapse fuels hallucinations
Untracked retrieval corpora dilute attention across long context windows. Supplying provenance-verified evidence links predicts hallucination resistance at r = 0.63, preventing agents from fabricating API parameters

2. Missing guardrail boundaries enable prompt injection
Placing untrusted user inputs alongside trusted policies without delimiter isolation leaves runtime execution unprotected. Explicit refusal boundaries predict adversarial resistance at r = 0.60

3. Conflicting instructions trigger policy drift
Overloaded system prompts create contradictory precedence rules. Scoring instruction consistency across turns predicts constraint compliance at r = 0.57, eliminating random task abandonment

4. Untyped tool schemas break execution flow
Vague parameter definitions and hidden side-effects cause repeated schema retries. Formal typed interfaces predict tool execution fidelity at r = 0.47, stopping multi-step loop aborts

The Empirical Telemetry on GPT-6 Astra:
• Moving from poor to structured context increased benchmark task scores from 3.15 to 5.49
• Tool execution accuracy surged from 3.46 to 6.25 without touching model weights
• Critical production failures dropped from 4.11 to 1.33 per session, delivering a 68% reduction in crashes
• Weak context was the cheapest per call at 392 tokens, proving that the real price of bad context is paid in catastrophic downtime

Reliable autonomy is not an optimization problem over prompt phrasing
It requires deterministic context assembly, isolated preflight scoring, and automated multi-juror evaluation harnesses

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

Anthropic quietly proved with Claude Code that the real moat in autonomous AI agents is not the model, but the runtime harness

The AI engineering stack reached its third major evolutionary boundary

Phase 1 was prompt engineering: tweaking text strings to steer completion distributions
Phase 2 was context engineering: packing RAG chunks and system prompts into expanding context windows
Phase 3 is harness engineering: building the runtime infrastructure that transforms stochastic models into deterministic software

As foundation model capabilities converge, the harness layer is the primary site of architectural differentiation

Terminal Bench 2.0 proved this empirically: holding the model completely constant and upgrading only the runtime harness caused task completion to jump from 52.8% to 66.5%

When millions of users connected OpenClaw to emails, terminals, and file systems, unconstrained autonomous loops collapsed into pseudo-orchestration, permission leaks, and catastrophic context rot

Researchers introduced SemaClaw to formalize personal agent harness engineering across four interconnected systems:

1. The four-layer capability stack
Instead of dumping every tool into the system prompt, capabilities divide across four clear boundaries: MCP tools extend the external action space, subagents isolate reasoning contexts, skills lazily inject domain procedures on demand, and hooks serve as runtime harness clamp points

2. Two-phase hybrid DAG orchestration
Freeform agent swarms devolve into chaotic loops, while static workflows cannot adapt. SemaClaw decouples coordination into two stages: an LLM dynamically synthesizes a task dependency graph, and a deterministic scheduler executes tasks with isolated failure boundaries

3. Runtime PermissionBridge
Standard frameworks treat safety as superficial prompt instructions. SemaClaw embeds authorization directly into the execution engine as a native control primitive, intercepting high-risk file modifications and API calls for explicit human approval before execution

4. Three-tier knowledge sedimentation
Persistent agents require memory that compounds across months without polluting the prompt. SemaClaw partitions state across working context compaction, hybrid dense-sparse retrieval, and a human-editable Markdown wiki owned entirely by the user

The Production Telemetry:
Deploying full harness engineering across autonomous personal agent environments:
• Achieved a 13.7 percentage point accuracy jump on Terminal Bench without changing a single model weight
• Replaced context-heavy tool injections with progressive skill loading, cutting prompt bloat across complex CLI workflows
• Eliminated unprompted destructive actions by enforcing cryptographic PermissionBridge gates on terminal executions
• Maintained cross-session continuity across hundreds of multi-app tasks through structured Markdown sedimentation

Autonomous agents will not scale by waiting for bigger parameter counts or larger context windows
Production reliability is an infrastructure discipline, and the harness is the operating system of the agent era

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

Anthropic quietly proved with Claude Code that the real moat in autonomous AI agents is not the model, but the runtime harness

The AI engineering stack reached its third major evolutionary boundary

Phase 1 was prompt engineering: tweaking text strings to steer completion distributions
Phase 2 was context engineering: packing RAG chunks and system prompts into expanding context windows
Phase 3 is harness engineering: building the runtime infrastructure that transforms stochastic models into deterministic software

As foundation model capabilities converge, the harness layer is the primary site of architectural differentiation

Terminal Bench 2.0 proved this empirically: holding the model completely constant and upgrading only the runtime harness caused task completion to jump from 52.8% to 66.5%

When millions of users connected OpenClaw to emails, terminals, and file systems, unconstrained autonomous loops collapsed into pseudo-orchestration, permission leaks, and catastrophic context rot

Researchers introduced SemaClaw to formalize personal agent harness engineering across four interconnected systems:

1. The four-layer capability stack
Instead of dumping every tool into the system prompt, capabilities divide across four clear boundaries: MCP tools extend the external action space, subagents isolate reasoning contexts, skills lazily inject domain procedures on demand, and hooks serve as runtime harness clamp points

2. Two-phase hybrid DAG orchestration
Freeform agent swarms devolve into chaotic loops, while static workflows cannot adapt. SemaClaw decouples coordination into two stages: an LLM dynamically synthesizes a task dependency graph, and a deterministic scheduler executes tasks with isolated failure boundaries

3. Runtime PermissionBridge
Standard frameworks treat safety as superficial prompt instructions. SemaClaw embeds authorization directly into the execution engine as a native control primitive, intercepting high-risk file modifications and API calls for explicit human approval before execution

4. Three-tier knowledge sedimentation
Persistent agents require memory that compounds across months without polluting the prompt. SemaClaw partitions state across working context compaction, hybrid dense-sparse retrieval, and a human-editable Markdown wiki owned entirely by the user

The Production Telemetry:
Deploying full harness engineering across autonomous personal agent environments:
• Achieved a 13.7 percentage point accuracy jump on Terminal Bench without changing a single model weight
• Replaced context-heavy tool injections with progressive skill loading, cutting prompt bloat across complex CLI workflows
• Eliminated unprompted destructive actions by enforcing cryptographic PermissionBridge gates on terminal executions
• Maintained cross-session continuity across hundreds of multi-app tasks through structured Markdown sedimentation

Autonomous agents will not scale by waiting for bigger parameter counts or larger context windows
Production reliability is an infrastructure discipline, and the harness is the operating system of the agent era

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

This Google DeepMind paper is f*cking legendary

In the Kaggle GameArena competition, 78% of Gemini Flash losses had nothing to do with strategic blunders

The model lost because it repeatedly attempted illegal moves prohibited by the environment

This is the action applicability problem: frontier models excel at high-level reasoning, but left unconstrained, they hallucinate invalid parameters and crash against external runtime rules

Teams usually react with two expensive mistakes:
1. Fine-tune model weights on trajectory logs, which degrades general instruction following and burns tens of thousands of dollars
2. Hand-code rigid programmatic wrappers for every tool and API, creating a fragile maintenance burden

Google DeepMind proved that LLMs can solve this by synthesizing and debugging their own executable code harnesses

Instead of treating the harness as human-written plumbing, AutoHarness turns harness generation into program-space tree search guided by Thompson sampling:

1. Program-space Thompson sampling
The system maintains a search tree of candidate harness programs. Thompson sampling balances exploring distinct control-flow architectures against refining partially working code, using legal action rate as the heuristic guide

2. Closed-loop environment reflection
When a candidate harness executes, a Critic isolates failure points and error traces across parallel rollout sandboxes. The Refiner injects these runtime stack traces back into the model to patch validation logic in a targeted feedback loop

3. Decoupled action verification
The synthesized code wraps the LLM in a local rejection sampler. The model proposes strategic intent, while pure Python logic deterministically validates preconditions before any action reaches external runtime APIs

4. Compilation into zero-cost code policies
Pushing the technique to its limit, the model synthesizes the entire decision policy into pure executable Python. Decision-making shifts entirely to local deterministic code, eliminating runtime LLM inference calls and cutting token costs to zero

The Production Telemetry:
Evaluated across 145 diverse environments on the TextArena benchmark:
• Synthesized harnesses achieved a 100% legal action rate across all 145 environments in an average of only 14.5 iterations
• Enabled a lightweight Gemini Flash agent to beat Gemini Pro in head-to-head matches with a 56.3% win rate
• The compiled zero-token code policy scored a 0.870 average reward, outperforming GPT-5.2-High (0.844) and Gemini Pro (0.707)
• Eliminated hundreds of dollars in test-time inference spend, running complex logic locally with zero API latency

Model capability is a commodity; the programmatic harness around the model determines production success
Automating harness synthesis turns fragile prompt generators into self-contained, deterministic software systems

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

This Google DeepMind paper is f*cking legendary

In the Kaggle GameArena competition, 78% of Gemini Flash losses had nothing to do with strategic blunders

The model lost because it repeatedly attempted illegal moves prohibited by the environment

This is the action applicability problem: frontier models excel at high-level reasoning, but left unconstrained, they hallucinate invalid parameters and crash against external runtime rules

Teams usually react with two expensive mistakes:
1. Fine-tune model weights on trajectory logs, which degrades general instruction following and burns tens of thousands of dollars
2. Hand-code rigid programmatic wrappers for every tool and API, creating a fragile maintenance burden

Google DeepMind proved that LLMs can solve this by synthesizing and debugging their own executable code harnesses

Instead of treating the harness as human-written plumbing, AutoHarness turns harness generation into program-space tree search guided by Thompson sampling:

1. Program-space Thompson sampling
The system maintains a search tree of candidate harness programs. Thompson sampling balances exploring distinct control-flow architectures against refining partially working code, using legal action rate as the heuristic guide

2. Closed-loop environment reflection
When a candidate harness executes, a Critic isolates failure points and error traces across parallel rollout sandboxes. The Refiner injects these runtime stack traces back into the model to patch validation logic in a targeted feedback loop

3. Decoupled action verification
The synthesized code wraps the LLM in a local rejection sampler. The model proposes strategic intent, while pure Python logic deterministically validates preconditions before any action reaches external runtime APIs

4. Compilation into zero-cost code policies
Pushing the technique to its limit, the model synthesizes the entire decision policy into pure executable Python. Decision-making shifts entirely to local deterministic code, eliminating runtime LLM inference calls and cutting token costs to zero

The Production Telemetry:
Evaluated across 145 diverse environments on the TextArena benchmark:
• Synthesized harnesses achieved a 100% legal action rate across all 145 environments in an average of only 14.5 iterations
• Enabled a lightweight Gemini Flash agent to beat Gemini Pro in head-to-head matches with a 56.3% win rate
• The compiled zero-token code policy scored a 0.870 average reward, outperforming GPT-5.2-High (0.844) and Gemini Pro (0.707)
• Eliminated hundreds of dollars in test-time inference spend, running complex logic locally with zero API latency

Model capability is a commodity; the programmatic harness around the model determines production success
Automating harness synthesis turns fragile prompt generators into self-contained, deterministic software systems

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

This Microsoft research paper is f*cking incredible

In long-horizon AI agent workflows, massive context windows are an illusion

As an autonomous agent crosses 15+ steps across APIs and terminal tools, raw interaction history explodes into tens of thousands of tokens

Teams assume frontier context sizes solve this, but production reveals two brutal failure modes:
1. Context distraction destroys reasoning: thousands of lines of verbose tool returns and stale intermediate steps drown out critical state cues
2. Inference economics collapse: massive KV cache expansion makes multi-turn rollouts painfully slow and computationally prohibitive

Standard workarounds break down immediately: FIFO truncation drops essential preconditions, vector retrieval shatters sequential execution flow, and reinforcement learning requires updating model weights that proprietary APIs keep locked

Researchers from Microsoft, KAIST, and Cambridge built ACON (Agent Context Optimization) to solve context management directly in natural language space

Instead of fine-tuning model weights or relying on hand-crafted prompts, ACON optimizes compression guidelines through contrastive textual gradients:

1. Contrastive failure attribution
The framework executes agents with and without compression across training tasks. By contrasting trajectories that succeed under full context against those that fail under compression, an optimizer model localizes the exact missing variable, dropped API parameter, or distorted state

2. Alternating two-phase optimization
Optimization alternates between two opposing objectives: Utility Maximization (UT) expands guidelines to prevent information loss, while Compression Maximization (CO) analyzes successful runs to aggressively prune state that downstream steps never accessed

3. Structured state schemas
Rather than vague conversational summaries, ACON forces working memory into five typed compartments: active reasoning, a strict runtime variable table, pending sub-tasks, completed milestones, and execution guardrails

4. Sub-cent compressor distillation
Invoking frontier reasoning models to compress every step introduces severe latency and expense. Microsoft distills the prompt-optimized teacher into compact open models like Qwen-14B and Phi-4, retaining 95% of teacher performance while cutting per-example cost by 99.1%

The Production Telemetry:
Evaluated across AppWorld, OfficeBench, and Multi-objective QA over complex multi-app tasks:
• Slashes peak token usage by 26% to 54% while matching or exceeding uncompressed baseline accuracy
• Reduces compressor cost from $0.045 to $0.0004 per task with distilled small models
• Improves small agent task success by up to 46% by eliminating context distraction
• Consistently beats FIFO sliding windows, vector retrieval, and LLMLingua across all difficulty tiers

Scaling long-horizon agents is not about stuffing millions of raw tokens into the context window
Optimizing structured working memory in natural language space turns bloated execution traces into efficient state representations

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

This Microsoft research paper is f*cking incredible

In long-horizon AI agent workflows, massive context windows are an illusion

As an autonomous agent crosses 15+ steps across APIs and terminal tools, raw interaction history explodes into tens of thousands of tokens

Teams assume frontier context sizes solve this, but production reveals two brutal failure modes:
1. Context distraction destroys reasoning: thousands of lines of verbose tool returns and stale intermediate steps drown out critical state cues
2. Inference economics collapse: massive KV cache expansion makes multi-turn rollouts painfully slow and computationally prohibitive

Standard workarounds break down immediately: FIFO truncation drops essential preconditions, vector retrieval shatters sequential execution flow, and reinforcement learning requires updating model weights that proprietary APIs keep locked

Researchers from Microsoft, KAIST, and Cambridge built ACON (Agent Context Optimization) to solve context management directly in natural language space

Instead of fine-tuning model weights or relying on hand-crafted prompts, ACON optimizes compression guidelines through contrastive textual gradients:

1. Contrastive failure attribution
The framework executes agents with and without compression across training tasks. By contrasting trajectories that succeed under full context against those that fail under compression, an optimizer model localizes the exact missing variable, dropped API parameter, or distorted state

2. Alternating two-phase optimization
Optimization alternates between two opposing objectives: Utility Maximization (UT) expands guidelines to prevent information loss, while Compression Maximization (CO) analyzes successful runs to aggressively prune state that downstream steps never accessed

3. Structured state schemas
Rather than vague conversational summaries, ACON forces working memory into five typed compartments: active reasoning, a strict runtime variable table, pending sub-tasks, completed milestones, and execution guardrails

4. Sub-cent compressor distillation
Invoking frontier reasoning models to compress every step introduces severe latency and expense. Microsoft distills the prompt-optimized teacher into compact open models like Qwen-14B and Phi-4, retaining 95% of teacher performance while cutting per-example cost by 99.1%

The Production Telemetry:
Evaluated across AppWorld, OfficeBench, and Multi-objective QA over complex multi-app tasks:
• Slashes peak token usage by 26% to 54% while matching or exceeding uncompressed baseline accuracy
• Reduces compressor cost from $0.045 to $0.0004 per task with distilled small models
• Improves small agent task success by up to 46% by eliminating context distraction
• Consistently beats FIFO sliding windows, vector retrieval, and LLMLingua across all difficulty tiers

Scaling long-horizon agents is not about stuffing millions of raw tokens into the context window
Optimizing structured working memory in natural language space turns bloated execution traces into efficient state representations

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

This Google DeepMind paper is f*cking superb

When an autonomous AI agent executes a 30-step shell workflow, binary security filters fail by design

Most teams secure tool calls with local hard gates: if a classifier flags sensitive data or prompt injection above a fixed threshold, abort; otherwise, execute

In production, that approach creates a silent failure mode:
A moderate-risk file read feeds into a filtered pipe, which feeds into an external network request. Every individual step clears the local gate, yet the cumulative probability of data exfiltration across the trajectory becomes catastrophic

Discretizing continuous risk into binary allow/deny decisions at isolated steps forces an impossible trade-off: over-block safe actions and kill agent autonomy, or under-block borderline actions and leak production secrets

Google DeepMind published an architecture for sound probabilistic verification in AI agent runtimes to solve this

Instead of judging isolated tool calls with local thresholds, the runtime tracks cumulative trajectory risk using formal program analysis and mathematical optimization:

1. Datalog taint lineage
The runtime compiles multi-turn bash commands, environment variables, and intermediate files into a Datalog derivation graph. Taint tracking maps data flow across pipes and subshells, preserving exact lineage without relying on fragile prompt heuristics

2. Correlated detector modeling
Standard safety checks assume classifier errors are independent, massively underestimating compound risk. Google DeepMind formulates multi-detector uncertainty under worst-case distributional bounds, guaranteeing coverage even when classifiers share common blind spots

3. Semidefinite Programming relaxations
Computing exact cumulative risk over continuous execution graphs is NP-hard. DeepMind applies Semidefinite Programming (SDP) relaxations to calculate sound upper bounds in polynomial time, turning exponential mathematical proofs into real-time runtime checks

4. Trajectory-level policy gating
The agent preserves continuous probability distributions across the entire execution history. The monitor only blocks an action when the cumulative trajectory risk breaches the global safety envelope, allowing safe intermediate exploratory steps to proceed uninterrupted

The Production Telemetry:
Validated across 574 agent trajectories on Intercode-NL2Bash and ATBench:
• Achieved 100% security enforcement without sacrificing task completion rates
• SDP relaxations matched exact certified verification bounds while cutting latency from minutes to milliseconds
• Caught multi-turn data exfiltration chains that bypassed state-of-the-art per-step guardrails
• Maintained sub-50ms verification overhead across complex multi-step terminal environments

Securing autonomous agents is an optimization problem over continuous trajectories, not a binary filter on isolated tool calls
Sound probabilistic verification turns prompt heuristics into provable runtime software infrastructure

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

This Google DeepMind paper is f*cking superb

When an autonomous AI agent executes a 30-step shell workflow, binary security filters fail by design

Most teams secure tool calls with local hard gates: if a classifier flags sensitive data or prompt injection above a fixed threshold, abort; otherwise, execute

In production, that approach creates a silent failure mode:
A moderate-risk file read feeds into a filtered pipe, which feeds into an external network request. Every individual step clears the local gate, yet the cumulative probability of data exfiltration across the trajectory becomes catastrophic

Discretizing continuous risk into binary allow/deny decisions at isolated steps forces an impossible trade-off: over-block safe actions and kill agent autonomy, or under-block borderline actions and leak production secrets

Google DeepMind published an architecture for sound probabilistic verification in AI agent runtimes to solve this

Instead of judging isolated tool calls with local thresholds, the runtime tracks cumulative trajectory risk using formal program analysis and mathematical optimization:

1. Datalog taint lineage
The runtime compiles multi-turn bash commands, environment variables, and intermediate files into a Datalog derivation graph. Taint tracking maps data flow across pipes and subshells, preserving exact lineage without relying on fragile prompt heuristics

2. Correlated detector modeling
Standard safety checks assume classifier errors are independent, massively underestimating compound risk. Google DeepMind formulates multi-detector uncertainty under worst-case distributional bounds, guaranteeing coverage even when classifiers share common blind spots

3. Semidefinite Programming relaxations
Computing exact cumulative risk over continuous execution graphs is NP-hard. DeepMind applies Semidefinite Programming (SDP) relaxations to calculate sound upper bounds in polynomial time, turning exponential mathematical proofs into real-time runtime checks

4. Trajectory-level policy gating
The agent preserves continuous probability distributions across the entire execution history. The monitor only blocks an action when the cumulative trajectory risk breaches the global safety envelope, allowing safe intermediate exploratory steps to proceed uninterrupted

The Production Telemetry:
Validated across 574 agent trajectories on Intercode-NL2Bash and ATBench:
• Achieved 100% security enforcement without sacrificing task completion rates
• SDP relaxations matched exact certified verification bounds while cutting latency from minutes to milliseconds
• Caught multi-turn data exfiltration chains that bypassed state-of-the-art per-step guardrails
• Maintained sub-50ms verification overhead across complex multi-step terminal environments

Securing autonomous agents is an optimization problem over continuous trajectories, not a binary filter on isolated tool calls
Sound probabilistic verification turns prompt heuristics into provable runtime software infrastructure

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[mirku @mirku21]

This NVIDIA paper is f*cking brilliant

Teams trying to train multi-turn coding agents with reinforcement learning hit an infrastructure wall almost immediately

Most agent frameworks make a fatal architectural mistake: they embed the execution rollout directly inside the training loop

This creates two massive bottlenecks in production:
1. Conflicting workloads: Agent rollouts are IO-heavy with Docker sandboxes and tool delays, while policy updates are compute-heavy GPU passes. Forcing them into one process leaves expensive GPU clusters sitting idle
2. Brittle migrations: Changing a sandbox tool or adding an API requires rewriting the entire training pipeline

Researchers from NVIDIA built ProRL Agent to fix this, introducing Rollout-as-a-Service for autonomous multi-turn systems

Integrated directly into NVIDIA NeMo Gym, the architecture decouples execution from model training through three decoupled layers:

1. Standalone rollout service
Instead of running agent code inside the trainer, ProRL Agent serves the full execution lifecycle over an asynchronous HTTP API. The RL trainer submits tasks and receives completed trajectories with reward signals without managing sandboxes

2. Pluggable task abstraction
The system standardizes all domain logic through an AgentHandler interface with three clean lifecycle methods: init sets up the environment, run drives the multi-turn tool loop, and eval computes verifiable rewards

3. Rootless container execution
Standard Docker requires root daemon privileges that break on shared enterprise clusters. ProRL Agent runs sandboxes on rootless Singularity containers with per-container loopback IPs, making massive multi-agent rollouts possible on shared Slurm setups

The Production Telemetry:
Validated across software engineering, math, and STEM environments:
• Drives end-to-end multi-turn RL training across 4B, 8B, and 14B models on SWE-Bench Verified
• Cuts GPU idle time by eliminating rollout synchronization stalls
• Native token-in and token-out streaming avoids re-tokenization drift across training iterations

Scaling autonomous agent intelligence requires separating the execution harness from the training stack
Rollout-as-a-Service turns messy environment interactions into scalable API infrastructure

Read the complete breakdown in the article below ↓

Bookmark this for your agent architecture notes