Glean 拾遗
Recent picks

11picks · chronological

11-15

Why Cloud Agents ignore /poteto-mode — and how to vendor pstack

A field guide to running pstack (Lauren Tan's engineering-standard plugin) across Cursor's split setup: Grok Bot coordinates and spawns, Cloud Agents do the work in isolated VMs and open PRs. The failure mode it targets: account plugins and ~/.cursor/skills are not copied to the cloud VM, so /poteto-mode silently never loads. Fix is to sparse-checkout pstack's skills/ and agents/ and rsync them into the repo's .cursor/skills and .cursor/agents, keep those paths tracked in git, and give each runnable app its own verify-<app> skill so verification means launch/drive/evidence instead of the model asserting it looks fine. Also covers coordinator prompt templates, the permission gap between Autopilot-stack and Autopilot-full (the latter needs a fresh verifier's clean verdict before merge), and a pitfall list. For engineers already running Cloud Agents who want skill distribution and verification pinned down.

x.com · 9 min · Agent Harness · Agent Skills · Coding Agents
11-13

The Harness Is the Machine: Seven Invariants for Agent Engineering

The essay argues that agent failures come from the environment around the model, not from prompts. It lays out seven harness invariants: bound the contract before the first token, feed the context window only AST symbol slices, quarantine writes in ephemeral git worktrees, persist state to disk as receipt.md, gate merges on compiler and test exit codes rather than model claims, strip credentials and network egress, and emit a machine-readable audit receipt per run. It cites a before/after on a multi-file refactor (18% completion bare, 89% with a harness), plus a .claude/rules YAML example, a pre-verify.sh sensor hook, and a receipt template. Useful for engineers wiring coding agents into CI, though the headline numbers are unsourced, the model version names are fictional, and the post ends with promotion.

11-12

1,000 agents, no researcher: a self-organized Lean proof of Fermat

A thousand agents running an early build of Claude Fable 5.2 formalized Fermat's Last Theorem in Lean in 28.7 hours, without the Prove2Me coordination platform or a researcher steering the work. Each agent got its own network-isolated sandbox, a Git branch, a shell, Lean plus Mathlib, and access to a shared Postgres database. The lead model spent its first ten minutes creating five tables to announce orders, assign statements, collect notes, queue subtasks and log finished work; helpers then claimed tasks and reported progress through them. After most agents judged 47 of 60 statements infeasible, the lead reallocated nearly everyone to the remaining ten, and later built a 2,418-node task tree up to ten levels deep for Langlands–Tunnell. The post details the safety stack—sandboxing, a blocking classifier on every tool call, and offline monitoring—and concedes that agents still misjudge difficulty and quit early.

claude.dev · 23 min · Agent Harness · Ai Safety · Formal Verification
11-11

Prompting Claude Fable 5.2: effort, early stops, code ownership

A migration guide for prompting Claude Fable 5.2, organized by the symptom you observe rather than by feature. Anthropic's position: most of the capability gain already lands at high effort, the medium-to-high step is the main one, and gains above high are uneven and task-dependent, so effort must be re-swept alongside the prompt instead of carried over from Fable 5.1 or Opus 5.5. The doc ships internal test numbers: a completion-prompt cut sessions ending with doable work left by roughly half while raising output tokens about 30 percent; telling the model it owns the code base raised repeated-code merging from under a tenth to about half of tries, at 1.5x output tokens and one-in-six-to-ten behavior changes that closing summaries often omit. It also covers subagent cost descriptions cutting delegation by a third, progress-update thinking blocks being empty at display: omitted, preserved thinking invalidating blocks when harnesses edit earlier turns, and the stop_reason: refusal categories. For engineers migrating an agent harness or maintaining long system prompts and memory files.

platform.claude.com · 22 min · Agent Harness · Agentic Coding · Claude
11-10

Super-agent Design: Router/Worker Split for Always-On Agents

The DeepSeek Harness team applies classic systems ideas to agent architecture. A long-lived Router session handles all human interaction and task dispatch but never executes work; context-isolated Workers run tasks concurrently and subscribe directly to event Threads, so follow-up events bypass the Router. Environment events (Triggers) are filtered by code fast paths before any model call, the context window is treated as a cache with Inline/Spill plus multi-hop Chain of Recall, and an external Watchdog session checks whether Workers are actually making progress. In a synthetic ablation, the two-level design finished tasks at p50 12.4 / p95 15.7 minutes versus 20.4/29.5 for a single session with a subagent tool; removing pass-through raised Router cache-read tokens 37%. The authors flag synthetic workloads and unresolved cloud/endpoint security.

11-10

Four-Layer Agent Stack: Prompt vs Context vs Loop vs Harness

A long-form X post that separates four commonly conflated terms into one nested stack: the harness executes loops, each loop iteration assembles context, and context carries the prompts. For each layer it lists the unit of work, typical artifacts, and failure symptoms, plus a diagnostic table: quality decay after turn 15 means prune history (context), repeated identical edits mean missing memory and no-progress detection (loop), double writes and hung subprocesses mean idempotent retries and timeouts (harness). The headline claim: if verification never runs, no prompt edit helps. It cites Karpathy on context engineering, Boris Cherny on loops, and a LangChain Deep Agents Terminal-Bench 2.0 gain from harness changes alone — without numbers. Useful as a layered triage checklist for engineers shipping production agents.

x.com · 16 min · Agent Engineering · Agent Harness · Agent Loops
11-09

Harness, Loop, Graph: Which Layer Actually Broke Your Agent

The author splits agent failures into three layers: the harness (everything around the model — tools, memory, permissions, traces), the loop (a check that can genuinely fail, plus feedback and exits), and the graph (dependencies and state handoff between loops). The claim is that each layer fixes a different class of failure, and that most engineers burn weeks editing prompts or swapping models when the real defect lives elsewhere. Concrete patterns include a task contract with an explicit done_when field, an AGENTS.md file that acts as a map instead of a manual, retry loops that exit when the same evidence appears twice, and an early-start test that removes fake arrows between steps. The author concedes most tasks should collapse back to a single loop, and that drawing a twelve-node graph first is a common mistake. Suited to engineers building agent workflows. Second-hand synthesis, no original measurements.

11-09

The Harness Is the Machine: Task Contracts, Worktrees, Receipts

A long-form X post outlining a production architecture for coding agents. The thesis: when an agent fails a multi-file refactor, the problem is not the prompt or the model but the environment around it — the harness. The author lays out a seven-stage pipeline: Opus compiles a task_contract.json with path allowlists and a cost/turn/timeout budget; the harness spawns an isolated git worktree; Sonnet edits only inside the boundary; Haiku validates every tool call parameter; a separate model acts as adversarial skeptic against the diff; a pre-commit hook checks test exit codes and signs a receipt.json; failures crystallize into rules, skills, and regression evals. Includes contract schema, isolate_worktree.sh, pre-tool.sh, receipt format, and a 10-point pre-flight checklist. Caveat: the Opus/Sonnet/Haiku/Fable 5.5 model names and the 18%→95% success numbers are unsourced, and the post ends with a Telegram funnel link.

x.com · 20 min · Agent Engineering · Agent Harness · Claude Code
11-09

The Complete Guide to pstack, Pt. 1: Verification Is All You Need

poteto argues that a verification skill — an agent's ability to drive the app, screenshot it, read traces and confirm its own change — is critical infrastructure rather than a nice-to-have, because it takes the human out of the loop. The post walks through /create-verification-skill: wrap dev-environment control in an agent-friendly CLI (doctor, snapshot, screenshot, wait-settle, feature-flag), then catalog every feature in a markdown Feature Map describing what it does, how a user reaches it, and known gotchas. She advises against scaling with git worktrees (roughly 10 agents per machine before resources bite) and recommends Cursor cloud agents plus /swarm for parallel verification runs. Wired into a scheduled routine, the skill can auto-reproduce user bug reports from Slack. The CLI design rules — --dry-run on destructive commands, descriptive errors, JSON output, progressive disclosure via subcommands — are the most transferable part. Claims of 2,000 PRs/month and 100-1000x output come with no measurement.

x.com · 19 min · Agent Harness · Agent Skills · Agent Tool Design
09-20

Balyasny: evaluating and governing frontier models at $38B scale

An interview with Balyasny Asset Management's chief AI officer on how a $38B multi-strategy firm puts frontier models into production. BAM evaluates new models on thousands of real financial tasks with verifiable outcomes — equities, macro, commodities — both standalone and inside its own agentic environment using the same tools and files its users have, watching for numerical errors, missed coverage and retrieval failures. On the relevant subset Claude Fable 5 scored 89.4% versus 86.1% for the prior production model; a set of economics problems no model had ever solved finally passed, and BAM re-ran and independently re-checked the eval before accepting the result. Merger-arbitrage packages dropped from three-to-five days to under one, with a roughly 30-minute agent run and mandatory human review. Governance is framed as controls around the model — data boundaries, least privilege, tool-level permissions, logging, human approval — not as model selection. Note this is vendor-published customer material.

claude.com · 8 min · Agent Evaluation · Agent Harness · Agent Infrastructure
08-21

DeepSeek Harness: A Plugin-Centric Runtime for AI Agents

DeepSeek Harness (dsh) is an open-source agent harness from DeepSeek AI with a plugin-everything architecture powered by Cordis, a framework designed around spatiotemporal composability. It is currently in developer preview, so breaking changes are expected. You can run it from npm or from source, and it launches a local Web UI at 127.0.0.1:3080 by default. The project aims to be a modular runtime for building and operating AI agents, and is suited for engineers who want an extensible, self-hosted agent infrastructure rather than a closed product. Community support is available via GitHub Discussions and Discord, and plugins can use the 'dsh-plugin' topic for discoverability.

github.com · 2 min · Agent Harness · Agent Infrastructure · Agents