1. The Harness Playbook — stencil.so

  • Why read: Architectural takeaways on why simple chat loops break down and how running a harness like a game engine makes rewinds, forks, and resumes work reliably.
  • Summary: Drawing on lessons from building omp, the author argues that the harness should absorb system complexity instead of pushing it onto users or plugins. Like a modern game engine, an agent harness needs an authoritative journaled state so runs can pause, fork, or rewind cleanly. Host policy should stay isolated from sandboxes, which should only receive bounded, cancellable tasks whether running in a local TUI or a cloud worker. Model and provider quirks belong in structured compatibility tables rather than scattered conditionals, and UI views should remain pure state projections rather than independent sources of truth.
  • Read more

2. Outcome Machines Need Outcome Graphs — jlowin.dev

  • Why read: How to combine agent autonomy with deterministic guardrails so erratic one-shot prompts become predictable workflows.
  • Summary: Enterprise automation across thousands of runs requires structured execution rather than open-ended prompting. Directed Agentic Graphs solve this by giving models autonomy inside individual steps while the orchestrator enforces boundaries at every handoff. At each transition, the orchestrator inspects generated evidence and restricts sensitive actions, such as blocking refund tools until eligibility passes deterministic checks. This structure lets teams track per-task costs, spot human-review bottlenecks, and measure the real ROI of model swaps.
  • Read more

3. How River takes security work from a fix to merge — Shopify

  • Why read: How Shopify built a Slack-based agent inside its main monorepo to lift vulnerability patch merge rates from 10% to 80%.
  • Summary: Writing a patch is straightforward; getting it through CI, lockfile rebases, and reviews in a busy monorepo is where automation usually stalls. River runs in Slack to rebase moving lockfiles, fix mechanical build failures, and keep branches green without engineering overhead. When a change introduces breaking behavior or product tradeoffs, River asks code owners for a specific decision instead of handing them an open-ended debugging task. It only flags an issue resolved after verifying the fix on the default branch post-merge. Prompts handle narrow judgment calls, while repository checks, deduplication, and completion verification live in deterministic code.
  • Read more

4. Project HydraFusion: Frontier quality via multi-model orchestration — The GitHub Blog

  • Why read: How GitHub routes tasks across model families in Copilot CLI to beat standalone frontier models and cut inference costs by 67%.
  • Summary: GitHub’s HydraFusion replaces static model selection in Copilot CLI with dynamic routing based on task difficulty. Depending on the job, it uses a single fast model, a tiered cascade with escalation rules, or cross-model review passes. On TerminalBench 2.1, it beat Claude Opus 5 by 4.9 percentage points while cutting costs by 67%. The setup isolates reviewers in read-only sandboxes while solvers edit code in the active workspace. It highlights how routing and verification logic can drive higher margins and better accuracy than defaulting to one frontier model.
  • Read more

5. Your Agent Doesn’t Know How to Wait — Medium

  • Why read: Why polling in agent loops inflates token spend, and how server-side blocking and MCP Tasks keep context small.
  • Summary: When agents poll cloud APIs for long-running operations, resending full conversation histories on every check burns tokens unnecessarily. On database provisioning tests, server-side blocking cut execution steps by 80% and token usage by 26% compared to standard polling. Without dedicated waiting primitives, models also waste output tokens writing fragile shell polling scripts. Running asynchronous jobs through the MCP Tasks extension lets agents start operations, handle other work, and react to completion events. API designers should return operation IDs directly and prune schemas to stop resident context bloat over extended runs.
  • Read more

6. How to master GPT-6 Astra (Full Guide) — X (formerly Twitter)

  • Why read: Practical patterns for running GPT-6 Astra, covering task delegation, independent review steps, and prompt design.
  • Summary: Astra performs best as an orchestrator delegating scoped tasks to lower-cost workers like GPT-5.6 Terra and Luna. Worker agents should never grade their own output; production setups should route diffs and test logs through a separate read-only verifier. Prompts should define target outcomes, boundaries, and concrete proof of completion rather than step-by-step procedures. Keeping repository config files like AGENTS.md brief prevents instruction fatigue during long operations like database migrations.
  • Read more

7. Coasean economics of agent swarms — pathwaysai.org

  • Why read: An economic argument using Coasean transaction costs to explain why agent swarms will concentrate enterprise scale rather than fragment it.
  • Summary: As agent architectures move from fragile text search toward continual model fine-tuning and weight merging, firm economics shift. Ronald Coase showed that businesses expand when internal coordination costs fall; agent swarms lower internal friction, encouraging centralization over loose networks of solo operators. Because business knowledge is tacit, localized, and regulated, incumbents with rich operational data retain an advantage over pure model labs. This encourages holding companies to acquire traditional businesses, pool their operational logs to run private fine-tuning loops, and automate core workflows.
  • Read more

8. Astra just made half of agent startups obsolete, we got a free upgrade — X (formerly Twitter)

  • Why read: Why harness design limits model performance, and how converting production failure traces into regression tests turns model updates into easy wins.
  • Summary: Astra’s jump from 62.7% to 99.9% on ARC-AGI-3 came entirely from harness improvements, proving how much scaffolding matters. In production, agent bugs rarely come from bad reasoning; they usually stem from silent tool failures or stale environment states. Recording execution traces along with environment responses lets teams turn every bug into a regression test covering correctness, safety, recovery, and calibration. With that harness in place, validating a new frontier model takes hours of automated checks instead of weeks of live debugging.
  • Read more

9. Defying Gravity: The System of Record in the Age of AI — Battery Ventures

  • Why read: Battery’s thesis on why AI makes systems of record more valuable than thin action wrappers, reopening entrenched software markets.
  • Summary: The belief that AI commoditizes enterprise software into simple databases overlooks how essential domain data integrity is for agents. The ten-year contracts protecting legacy software are weakening as companies look for architectures that support automation. By owning both core data and task execution, modern systems of record can charge against labor budgets rather than per-seat software pricing. Sitting directly in operational workflows also lets them capture action traces and outcomes to fine-tune models, building data advantages that shallow action layers cannot match.
  • Read more

10. AI, tools and transformation — Benedict Evans

  • Why read: Why distributing AI licenses does little for enterprise productivity without overhauling underlying business processes.
  • Summary: The idea that AI turns every worker into an ad-hoc software developer misreads how enterprise software is adopted. Corporate operations alternate between improvised spreadsheet fixes and rigid platforms like SAP that enforce compliance across teams. Handing out AI tools boosts individual output much like personal computers and web browsers did decades ago, but it leaves cross-departmental bottlenecks untouched. Meaningful gains require redesigning workflows, managing regulatory requirements, and integrating backend systems, not just deploying chatbot logins.
  • Read more

11. Training frontier knowledge work agents: A 397B RL training guide with SkyRL — mercor.com

  • Why read: Mercor’s open-source guide on using reinforcement learning to train a 397B model on complex white-collar tasks.
  • Summary: Mercor published its code and post-training setup for running reinforcement learning on Qwen3.5-397B across mock office setups with documents, spreadsheets, and chat channels, lifting task completion by 70%. Notably, resolving sandbox disconnects, MCP tool bugs, and harness prompts added 6 benchmark points before RL training even began. The pipeline uses direct completion endpoints for precise token tracking, preventing re-tokenization mismatches during asynchronous policy updates. It offers a concrete blueprint for applying RL to professional work like legal analysis and financial modeling.
  • Read more

12. memory poisoning on a delay — X (formerly Twitter)

  • Why read: How malicious instructions can sit dormant in an agent's memory store for weeks before triggering in an unrelated user session.
  • Summary: Delayed memory poisoning is now cataloged as OWASP ASI06. Attackers no longer need database access; an agent browsing a poisoned page can log malicious instructions that survive context wipes and model upgrades, then trigger during a later session. Cisco's MemoryTrap disclosure in Claude Code shows how shared memory stores create risks across multi-tenant setups. Defending against this requires memory expiration windows, trust-ranked retrieval, and inspecting stored memories at read time rather than relying only on write-time filters.
  • Read more

13. Where Does the Permission Live? — X (formerly Twitter)

  • Why read: Why baking company data into model weights breaks permissions and compliance, and why facts belong in an external store.
  • Summary: Training enterprise facts into neural network weights makes granular access control and ethical walls nearly impossible. An agent cannot simply refuse an unauthorized query, because the refusal confirms the information exists; restricted data must be entirely absent from the prompt. Sentra addresses this by compiling documents into an append-only log of atomic facts tagged with timestamps and permissions. At query time, the system filters out restricted facts before generating a temporary graph for the model to use and immediately discard. This reserves model weights for reasoning while keeping facts in an external layer that supports audits and GDPR deletions.
  • Read more

14. Connecting every app to every other app — val.town

  • Why read: How MCP uses Dynamic Client Registration and Client ID Metadata to cut through manual OAuth setup across applications.
  • Summary: App integrations scale poorly when every pair requires manual OAuth registration and developer portal setup. By adding Dynamic Client Registration and Client ID Metadata Documents to the MCP specification, apps can provision credentials and authenticate on demand. Val Town demonstrated this by spinning up thousands of app connections without manual configuration. Because MCP combines dynamic authentication with model-interpreted schemas on both sides, agents adapt to interface changes without breaking, moving teams away from hardcoded API keys.
  • Read more

15. The Harness Premium — beehiiv.com

  • Why read: How enterprise vendors price agent software, and why buyers still choose predictable seat plans over pure outcome billing.
  • Summary: Recent earnings from GitLab and Box show enterprise software margins staying in the harness layer: governance, auditing, and context management. Model inference is commoditizing, especially with providers discounting prompt caching for repetitive agent loops. While outcome billing gets attention, enterprise buyers still prefer seat licenses bundled with usage credits to keep costs predictable. Software pricing is settling on a hybrid model: a fixed platform fee for orchestration, paired with metered credits for heavier runs.
  • Read more

Themes from yesterday

  • Harnesses capture the margin as models commoditize: Engineering effort and software margins are consolidating in the harness layer: journaled state management, deterministic outcome graphs, and platforms (like GitLab and Box) that charge software premiums for orchestration while treating model tokens as pass-through costs.
  • Tiered multi-model orchestration replaces single-agent loops: Workflows like GitHub’s HydraFusion and GPT-6 Astra show production systems moving away from monolithic agent runs. Advanced models plan and coordinate, cheaper models execute bounded tasks, and read-only verifiers check output before state changes take effect.
  • Trace-driven regression evals make model upgrades predictable: Testing models against real failure traces matters more than benchmark scores. Recording execution logs and environment responses into permanent test suites lets teams adopt new frontier model releases in hours without risking live customer regressions.
  • Permissions, compliance, and memory attacks anchor systems of record: Permission boundaries, GDPR erasure rules, and delayed memory poisoning attacks (OWASP ASI06) show why proprietary data cannot live in model weights. Keeping facts in external, auditable systems of record preserves security and access control while letting models focus on reasoning.