Chronograph

Graph View

2026-08-13

10 min read

Martin Rosén-Lidholm
Martin Rosén-Lidholm

Daily D4 Digest — 2026-08-13

TL;DR

  • Agentic workflows are now converting 56K-line legacy Fortran codebases with zero chemistry-relevant deviations across 612 test runs, using version-controlled specs the agents themselves authored
  • Tool architecture — not just tool capability — is a critical design lever: Python CodeAct interfaces cut token usage 56% while matching task performance
  • A formal argument for runtime safety contracts backed by audit of 52 agent incidents exposes an 8-12× publication imbalance between training-time and deployment-time safety research
  • GPU-resident agent control paths yield 1.2-2.4× speedups by avoiding host round-trips; RL-based datacenter power control enables ~2× power oversubscription
  • EvoX Genesis built a 250K-line C compiler over 120 hours for $44 by making the project persistent while agents remain finite-lived

Call to Action

  • Adopt runtime contracts for agent safety now: Review the Agent Trajectory Schema proposed in this paper and evaluate its preventive+evidential gating against your current agent harness
  • Benchmark your tool architecture: The tool architecture study shows 56% token savings from CodeAct-style interfaces — profile your agent’s tool surface for similar wins
  • Evaluate memorywire for agent memory interop: If you’re running multiple memory backends, the memorywire spec with its MCP-composable design is worth a spike

D1 — Agentic Engineering

Legacy HPC modernization at production scale. The most impressive D1 result today: three prompt-specialized Claude Code agent roles converted 56,448 lines of 48-year-old GAMESS Fortran 77 to Fortran 2008, achieving bit-for-bit reproduction of chemistry energies across 612 test runs (zero deviations at the 12th decimal). The key architectural insight is that agents operated under a version-controlled specification they themselves authored and revised, while humans held only a small number of gates. The boundary of safe delegation was precisely where the verification oracle’s coverage ended. This is the Specify → Verify → Apply lifecycle in practice, with the oracle acting as the “terraform plan” equivalent.

Persistent projects, ephemeral agents. EvoX Genesis inverts the usual agent persistence model: the project is the persistent entity while agents are finite-lived. Using DeepSeek V4 Flash, it built a Rust-based C compiler (~250K lines) over 120+ hours and 1,000+ agent episodes for $44 in token costs, passing the complete c-testsuite. It also reimplemented 13 MESA modules (100K Fortran lines → 90K Rust lines) with 1.5-6.9× speedups. The recursive world model — where each local world is situated by an accepted version and repository path, and only accepted consequences advance version history — is a genuine contribution to how we think about long-horizon agentic development. (Cross-cutting: D4 — the $44 cost for a compiler is a striking efficiency datapoint.)

Tool architecture matters more than tool capability. A controlled study across 11,700 trajectories on coding agents shows that how tools are organized and exposed changes agent behavior dramatically, even when underlying capabilities are identical. Structured low-level interfaces improve consistency by up to 4.7×, natural-language search increases relevant file access by 11%+, and Python CodeAct-style interfaces achieve equivalent task performance with 41.6% fewer steps and 56.3% lower token usage. Cognitive scaffolding tools (letting agents record intermediate reasoning) showed limited effect. The practical implication: optimizing tool architecture is a higher-leverage investment than adding more tools. (Cross-cutting: D3, D4)

Agents as autonomous researchers, not just engineers. AutoWorldModel-Bench evaluates frontier coding agents (Codex-5.4, Claude Opus 4.6) on open-ended research tasks rather than engineering-to-spec problems. Across 64 sessions, agents improved world-model starters in 63, with 91% of winning edits being non-trivial research-style modifications (new objectives, representations, architectures) rather than hyperparameter tweaks. This benchmark matters because it characterizes the frontier of what agents can do when the improvement direction isn’t pre-specified.

Self-evolving network verifiers via counterexample-guided loops. A prototype system uses a coding agent in a counterexample-guided loop to autonomously extend a 3,000-line SMT-based network verifier, teaching it OSPF areas, BGP route reflection, and L3VPN over EVPN features it didn’t previously support. The agent proposes extensions to symbolic encodings while emulated routers serve as a ground-truth oracle. This is a compelling example of agents operating within a formally bounded verification framework — the oracle constrains the autonomy. (Cross-cutting: SCE — counterexample-guided refinement is exactly the simulation/verification pattern.)

D2 — AI in the Product

Governed multi-agent document processing in enterprise. GUIDE is a six-agent framework for converting enterprise guideline documents into deployment-ready artifacts, featuring a shared versioned rule store, schema-validated inter-agent contracts, and end-to-end provenance tracking. On 120 real-world documents, it achieved 96% success rate and reduced turnaround from 2-3 days to 40-125 minutes. The HITL escalation agent handles cases that fail consistency checks. The architecture — versioned rule store + schema contracts + provenance — is a template for governed multi-agent product features. (Cross-cutting: D1, SCE)

D3 — Build for Agents

memorywire: a vendor-neutral wire format for agent memory. The v4 release of memorywire defines a JSON-Schema 2020-12 wire format for five memory operations (remember, recall, forget, merge, expire) over four memory types, with an optional HITL governance channel. It ships with five backend adapters (sqlite-vec, mem0, Letta, Cognee, pgvector) and positions itself to compose with MCP rather than compete. The adversarial-fusion experiment showing RRF maintains recall@5=1.0 against rank-0 injection attacks is a useful security property. The provenance field as the primary lever for recovering poisoned stores is a design insight worth noting.

Transactional state governance for long-lived agents. The Continuity Kernel formalizes agent state as an activation contract: untrusted components propose typed changes against an exact predecessor head, and a short activation transaction revalidates ownership, authority, freshness, and effect uniqueness before atomically advancing the branch head. Verified across 2.8M+ reachable states and 5.5M+ transitions with zero invariant violations. This addresses a real gap — most agent frameworks treat state as a mutable store without governance semantics, which breaks down with multiple concurrent writers. (Cross-cutting: D1, SCE — this is essentially event sourcing applied to agent state.)

Agent safety as runtime contract. The position paper argues compellingly that training-time safety (RLHF, DPO) is structurally insufficient for agents that execute code and mutate state. It proposes an Agent Trajectory Schema and Evidence Chain with both preventive (sandboxes, permission gates) and evidential (test runs, log captures, file diffs) faces. The audit of 28,560 NeurIPS/ICML/ICLR papers showing 8-12× more training-time than deployment-time safety publications quantifies a systemic blind spot. (Cross-cutting: D1, SCE)

D4 — Performance & Cost at Scale

RL-based GPU power control enables ~2× datacenter oversubscription. A PPO meta-controller that adapts generation parameters to measured power telemetry cuts power-limit violations by 89.8% while increasing token output by 18.1% and energy efficiency by 26.2% (tokens/MWh) at 7B scale. At 72B fleet scale, peak demand sits at 50-56% of nameplate, suggesting roughly twofold power oversubscription is feasible. The key insight is that workload-aware control (adapting generation concurrency based on power measurements) dramatically outperforms the static caps and reactive throttling that datacenters use today. An occupancy-versus-volume principle governs which actuators retain authority under model sharding.

GPU-resident agent control avoids host round-trips. The Ready Cohorts paper formalizes when agent control paths (route outcome → update state → emit next effect) expose enough concurrent work for GPU execution. Keeping GPU-computed binary decisions on-device instead of returning to the host yields 1.19-2.39× speedups across all tested configurations. At 100K target active sessions, exact cohort packing recovers 82% of opportunity lost at fixed window boundaries. This is relevant for anyone running high-concurrency agent services where the control plane between model and tool calls becomes the bottleneck.

Cheap-tier evolutionary optimization with cross-tier transfer. This cost optimization approach decouples the three LLM roles in evolutionary prompt optimization, running the high-volume answering role on the cheapest tier while reserving strong models for rare reflection/variation. Result: 5.6-14× lower search cost (up to 54× for reasoning models), with evolved prompts transferring upward to match or exceed same-tier optimization. Over 96% of search tokens land on the cheapest tier. Practically, this is a template for any multi-stage agentic pipeline where you can separate evaluation volume from generation quality.

Software Civil Engineering Lens

Today’s batch is unusually rich in SCE-relevant work. Several papers independently converge on the same structural insight: the unit of engineering discipline is shifting from the model to the trajectory/contract/specification.

The GAMESS modernization is the closest thing to a complete SCE case study we’ve seen. The agents operated under a version-controlled specification they helped author (formal spec), used bit-for-bit energy reproduction as the merge criterion (simulation/verification oracle), and the boundary of safe delegation was precisely where oracle coverage ended (bounded autonomy). The 612 test runs with zero deviations is the kind of evidence that could satisfy a “licensure” threshold. Critically, the paper explicitly notes that “the boundary of safe delegation lies exactly where the oracle stops seeing” — this is the clearest articulation of bounded autonomy we’ve encountered in practice.

The Agent Safety as Runtime Contract paper’s framing maps directly onto SCE’s codes/norms pillar. Their Agent Trajectory Schema with preventive and evidential faces is structurally analogous to building codes (what you can’t do) plus inspection requirements (prove what you did). The 8-12× publication imbalance between training-time and deployment-time safety research quantifies how far the field is from the “codes and norms” pillar.

The Continuity Kernel implements event sourcing for agent state with formal verification — 2.8M+ states checked with zero invariant violations. This is the “simulation” pillar applied to agent infrastructure itself: terraform plan for agent state transitions.

The self-evolving network verifiers demonstrate a pattern that could generalize: agents that autonomously extend verification systems, constrained by ground-truth oracles. This is the meta-level of SCE — using agents to build the verification infrastructure that will constrain other agents.

The throughline: professionalization is happening bottom-up. Practitioners are independently discovering that formal specs, verification oracles, runtime contracts, and bounded autonomy aren’t academic luxuries — they’re prerequisites for deploying agents that actually work at production scale. The GAMESS team didn’t cite SCE theory; they arrived at the same architecture because the problem demanded it.

Sources