We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
🔥 TOP SIGNAL
The practical unit of agentic coding is becoming an organization with a human-facing control plane, not a larger chat window. In Fences, not Sandboxes, Steve Yegge describes 18 long-lived Claude Fable “officer” seats for design, planning, and human-facing agents, alongside mostly headless Sol and Opus fleets for implementation, reviews, and monitoring; only Fable can talk to roughly 10 outside humans through Slack and email inside a 50–60-agent organization. This is an extreme experiment—21 Claude Max accounts and about $122k/month in equivalent API spend—so copy the coordinator/specialist boundary, not the burn rate.
⚡ TRY THIS
Build the alert → PR → review loop. On a slow-query alert: open an issue, schedule an implementer PR, have a reviewer agent check it, then ping a human; repeat until the app is fast. Matt Pocock proposed the loop, and Kent C. Dodds says Kody’s PlanetScale package can wire PlanetScale → GitHub → Cursor/Devin → Discord/Twilio. Start with one alert class and keep the human at the final gate.
Seed durable project memory at day zero. Use a prompt in this shape:
Create ADR skills from day 0 during planning; in every future planning/development session, consult and maintain the ADRs.Geoffrey Huntley reports that this recursive ADR loop keeps decisions available to later agent sessions.Make every review prove its target. Theo asked Opus 5 to review one specific PR; it ran the wrong diff command and reviewed the five most recently merged PRs instead. Before accepting an agent review, require it to state the target PR/commit range and exact diff command, then compare the changed-file list with the intended target.
Move the security boundary out of the prompt. Geoffrey Huntley calls harness
/permissioncontrols an anti-pattern and favors broad model access inside an ephemeral development environment, with least privilege enforced by the environment—his example is not shipping compilers on a production web server. If you test the idea, use a disposable CDE and keep production credentials and network access separate; this is a design argument, not a safety guarantee.
📡 WHAT SHIPPED
Managed Deep Agents 0.6.0 — LangChain automated Slack deployment: no manifest, OAuth redirects, or bot-token copying; one command provisions the app and makes the agent available in Slack.
Antigravity 2.0 VCS + terminal — the side panel now tracks working-tree changes made by agents, scripts, editors, and Bash; it adds Agent Edits/Uncommitted/Branch views, stage/unstage/commit actions, and an embedded terminal for tests, linters, builds, and package management. This closes the inspect → test → commit loop without context switching.
llm-anthropic 0.27 — adds compatibility with
anthropicPython library 1.0.0, whose HTTP dependency moved fromhttpxtohttpx2. Simon Willison’s compact Claude Code migration prompt was:Upgrade to anthropic>=1 - read https://raw.githubusercontent.com/anthropics/anthropic-sdk-python/refs/heads/main/MIGRATION.md and get the tests passing; it produced PR #84.Pi 0.84.3 — adds optional native PowerShell on Windows, staged/verified/atomic managed updates, session-scoped
/thinkingcontrols, detailedsession_compact_failedevents, and provider-neutraltoolChoicesupport.Codex / ChatGPT Work usage policy — Tibo says the five-hour limit will return for Plus accounts across ChatGPT Work and Codex, citing compute smoothing and users accidentally exhausting weekly usage; Pro $100 and $200 plans remain exempt for the coming months.
Agent UI performance: ClaudeDevs reports long responses on web and desktop are ~4× smoother after rebuilding the renderer to update only changing content, with stalls 9× less frequent, a 4.5× shorter worst freeze, and 120fps on a 120Hz MacBook. Theo’s implementation takeaway: stream complete paragraphs, code blocks, and tool calls—not token-by-token fragments.
🎬 GO DEEPER
Steve Yegge — Fences, not Sandboxes. Read past the org chart: Wheelhouse has 450 legal artifacts; rules tighten from custom practice to warnings, constitutional law, and finally mechanical refusal or alerting, while changes to the governance system itself require ratification, review, and a build. This is a concrete fleet-governance pattern, not a claim that a sandbox has been solved.
Kody: how it works. The worked example persists a
lastSeenEventIdcursor withpackageStorage(), keeps the GitHub credential as a runtime secret reference, and turns the export into a daily cron job. It leaves the job off while patching, checks the manifest and types before publishing, and skips email on quiet days—good scaffolding for idempotent agent jobs.walgit. Armin Ronacher presented Tobi’s weekend implementation as another case of building hard things with AI; Tobi describes a single Rust binary for S3-compatible object stores using WAL and CAS without another datastore, plus
bundle-urifor fast downloads of large repositories.
Editorial take: The edge is shifting from granting agents more autonomy to engineering the operating loop around them: one human boundary, durable state, bounded execution, and proof that the agent touched the intended code.
Direct answer: Wheelhouse provides an officer-seat and headless-fleet architecture with one external human boundary and a constitutional enforcement layer. Kody demonstrates a transient search/execute path that can be promoted into a Git-backed package with stored state and package-owned scheduling. Antigravity’s change is workspace-wide VCS visibility plus an embedded terminal, not merely better display of agent edits. Pi 0.84.3’s supplied notes give concrete Windows, update, thinking-control, API, compatibility, and runtime changes.
Fences, not Sandboxes
- Concrete topology: The reported Wheelhouse runs 18 long-lived Fable officer seats, mostly-headless Sol and Opus fleets for implementation, reviews, and monitoring, with Fable running those fleets. It contains roughly 50–60 agents; five interface with roughly 10 humans, and only Fable may talk to humans externally through Slack and email.
- Governance architecture: Wheelhouse contains a constitution, jurisprudence, courts, offices, jurisdiction, case law, registries, ledgers, rosters, and an enforcement arm built from fences, gates, ratchets, cameras, and jails. It currently has 450 legal artifacts covering seats/offices, runbooks, rulings, patrols/tripwires, authority envelopes, and mechanical patterns; the stated goal is mechanically proving that each Wyvern change is legal.
- Rule lifecycle and change boundary: User clarifications become recorded verdicts; postmortems create new rulings and doctrine; rules tighten from custom to advisories/warnings, then constitutional law, then mechanical refusal or alerting. Wheelhouse itself cannot be changed directly: changes require ratification and review, followed by a build before propagation.
- Why this coordinates agents: The essay describes the agents as amnesiac and interchangeable, coordinating through text; offices outlive holders, precedents outlive incidents, and jurisdiction determines who may act.
- Boundary semantics: A fence is a mechanism that turns an actor away when credentials or policy do not permit an action; the Slack/email restriction on Fable is the concrete example. The essay explicitly distinguishes this from a sandbox or super-wall: the intended control is role, practical context, and decision rules, enforced as polite refusal.
- Operational caveat: At hundreds of commits per day, idle agents become stale and clones fall behind unless they pull regularly; Wheelhouse therefore needs roles that poke and prod other agents. The author also reports capacity for 500 commits per day through the merge queue, averaging 270 per day, and roughly 600,000 lines of factory code and tests, mostly Bash.
- Portability caveat: Capturing institutional knowledge is described as taking weeks, months, or years, with laws unique to the organization; the intelligence grows around that organization’s databases, servers, pub/sub, observability, org chart, and workflows rather than being transplantable.
How Kody works
- Transient interaction loop: The walkthrough maps a natural-language question to reasoning that searches for a saved GitHub token and relevant memory, identifies
kody-bot, then executes a GitHub public-events fetch. AconversationIdis returned and passed into subsequent search/execute calls. - Concrete GitHub integration: The generated export uses the GitHub API with
Authorization: Bearer {{secret:githubAccessToken}}and keeps only publishedReleaseEvententries and repository-creationCreateEvententries. - Durableization lane: After the user approves reuse, the agent loads the package-authoring and lifecycle guides; the example says the authoring guide prefers a Git lane, registers a package stub, mints an authenticated Git remote, and receives write scope, an expiry, clone/setup commands, and Git author configuration.
- Package implementation and state: The package is a private
@you/...package exportingwhatShipped; its code usespackageStorage()to read and updatelastSeenEventId, stops scanning when it reaches that cursor, and advances the cursor to the newest returned event. The GitHub credential remains a runtime secret reference in the package code. - Cross-agent reuse: A later Kody-connected agent on a phone searches for the existing package and invokes
kody:@you/kody-bot-shipped/whatShipped, rather than having the model reconstruct the GitHub filter. - Scheduling boundary: The example distinguishes inbound webhooks from this use case and places recurring schedules under the package’s
kody.jobsmanifest. The daily wrapper calls the same export, sends mail only when the result is nonempty, and is configured for cron0 8 * * *inAmerica/Denver. - Promotion gate: The agent opens a repo session, writes/edits files, commits, runs manifest and type checks, and publishes. The job is initially disabled, is tested through a no-argument wrapper that returns
{ emailed: false }on a quiet day, and is enabled only in a later edit/commit/check/publish step; the final manifest showsenabled: true.
Antigravity VCS and terminal changes
- Workspace-wide change tracking: Antigravity 2.0’s right-side panel now shows not only agent-tool edits but also changes made by Python scripts, other editors, and Bash side effects. The stated purpose is to keep the panel synchronized with the working directory rather than forcing repeated
git statusandgit diffterminal checks. - Git-native review/actions: The UI offers Agent Edits, Uncommitted, and Branch views; branch diffs are relative to
origin/main, uncommitted workspace changes are included regardless of origin, and staged changes have a dedicated view. Users can stage/unstage files and commit directly from the sidebar. - Embedded command loop: The new terminal tab is intended for
git status, tests, linters, builds, package management, and other command-line tools. The post frames the combined diff, terminal, and Git controls as an end-to-end loop for inspecting changes, running commands, and pushing commits without context switching. - UI caveat: The interactive side-panel preview is explicitly a demonstrative simulation; its appearance and layout may differ from the actual product.
Pi 0.84.3 exact release details
- New features: Optional native PowerShell command execution is available on Windows through
defaultToolsand the SDK. Installer-managed updates now stage, verify, and atomically activate the selected release; the/thinkingselector gains searchable defaults, keeps selections session-scoped, and persists them explicitly with Ctrl+S. - Breaking API change:
GoogleThinkingLevelwas renamed toGoogleApiThinkingLevel, withResolvedGoogleThinkingLeveladded for normalized adapter levels. - Added integration/provider surface: The release adds optional routing session IDs for compaction summaries,
session_compact_failedextension events exposing failure reason/retry/source/error, provider-neutraltoolChoice, Anthropic refusal fallback with returned-model pricing, configurable OpenAI-compatible thinking-token budgets for vLLM/Qwen-SGLang/llama.cpp, China-specific ZAI Coding Plan models including GLM-4.6V vision and cost estimates, anddeepseek-v4-pro-0813in the Qwen Token Plan catalog. - Changed behavior: Inherited xAI models move to the Responses API with encrypted reasoning replay and make Grok 4.6 the default; several adapters now send Pi’s default
User-Agent; Windows/WSL keybindings avoid terminal-reserved shortcuts; package/runtime loading and syntax highlighting are deferred or bundled to reduce startup work; and session shares use canonical Radius URLs with the current system prompt and active tool definitions. - Coding-agent/runtime fixes: Failed extension factories no longer leave subscriptions, provider registrations, or default flags active;
/modeland/thinkingchoices no longer persist globally unless explicitly saved; JSON/RPCtoolcall_startevents now include tool-call ID and name; single-executable extension loading works; nested skills are discovered; compaction/branch-summary requests no longer expose tools; and single-objecteditinputs are accepted as one-edit arrays. - Compatibility and administration fixes: The notes also cover correct fallback-model pricing, verbatim OpenAI-compatible reasoning replay, GitHub Copilot login retry/policy behavior, Bedrock redacted-reasoning replay, Z.AI reasoning metadata, Azure
toolChoice, Kimi cache-read accounting, Google thinking-level maps, and preservation of administrator-managed file permissions and ACLs. - Operational fixes worth carrying into the brief: Update checks no longer offer an older registry version as a downgrade; offline/local model catalogs are retained more reliably; threshold auto-compaction works when providers omit streaming usage; and
--is supported as an end-of-options delimiter for dash-prefixed prompts.
- Firsthand scale/context: Steve Yegge reports spending about $122,000 per month (~$4,000/day) in API tokens across 21 Claude Max accounts, growing by two accounts per week, while building his 30-year game project Wyvern.
- Agent orchestration pattern: For ten weeks, Yegge says he has used Claude Fable 5 exclusively for design, planning, and human-facing agents; his architecture has 18 long-lived “officer” Fable instances, while mostly headless Sol and Opus fleets perform implementation, reviews, and monitoring, with Fable running them.
- Human-in-the-loop boundary: The organization contains roughly 50–60 agents, but only five interface with about 10 external humans; only Fable is permitted to communicate with humans through Slack and email. This suggests a replicable design: centralize human communication in a small, persistent coordinator layer and delegate execution, review, and monitoring to headless specialist fleets.
- Full essay: “Fences, not Sandboxes”.
- llm-anthropic 0.27 updates the LLM Anthropic plugin for compatibility with the
anthropicPython library v1.0.0, which migrated its HTTP dependency fromhttpxtohttpx2. - Firsthand workflow from Simon Willison: in Claude Code, he prompted Fable 5 to upgrade the dependency, read Anthropic’s migration guide, and get the tests passing:
Upgrade to anthropic>=1 - read https://raw.githubusercontent.com/anthropics/anthropic-sdk-python/refs/heads/main/MIGRATION.md and get the tests passing. The agent produced a resulting pull request, demonstrating a compact pattern for agent-assisted dependency migrations: provide the target version, point the agent to the authoritative migration guide, and require passing tests.
Kent C. Dodds points developers to Kody’s guide explaining what Kody is, what it does, and how it works: kody.codes/guides/how-kody-works.
- Matt Pocock proposes a recurring performance-agent loop: a PlanetScale slow-query alert opens a codebase issue, an implementer agent schedules a PR, a reviewer agent checks it, and the system pings a human for review before repeating.
- Kent C. Dodds says this can be wired together with Kody’s PlanetScale package (kody.codes/@kody/planetscale): use a GitHub package to turn the alert into an issue, trigger a cloud coding agent such as Cursor or Devin, and notify the human through a Discord or Twilio package.
Kent C. Dodds describes a firsthand technique for pruning code with an agent: when the agent resists removing a primitive, repeatedly ask “why” until you reach agreement on whether it should exist; he says this eventually succeeded and removed cognitive overload.
Peter Steinberger advocates moving away from software that cannot be changed through a prompt, positioning prompt-driven modifiability as a design goal for coding-agent workflows.
- Riley Brown recommends using Codex’s in-app browser for browsing during agent work. Derrick Choi’s linked tip says the ChatGPT in-app browser can be set as the default browser for links clicked inside the app.
Geoffrey Huntley argues that strong domain knowledge and experience can compress rebuilding a company or its products from years to “literally days.” He contrasts this with his former tendency to overthink perfect interfaces and data structures, favoring rapid execution and making difficult outcomes happen quickly.
Jason Zhou reports a firsthand operational issue with Claude Code: it is consuming “so much CPU,” and he asks other users how they handled it; the post provides no CPU measurement, version, diagnosis, or workaround.
- Geoffrey Huntley’s harness design recommendation: Treat
/permissionfunctionality as an anti-pattern; instead of constraining the model by limiting what it can access, assume broad access and build around ephemeral development environments (CDEs). He frames this as applying least privilege to the operating environment—for example, not shipping compilers on a production web server.
Geoffrey Huntley recommends installing the Antithesis skill-pack during development to catch correctness faults; he says it is usable and valuable even without access to Antithesis’s multi-verse debugger/Determinator.
Codex usage-policy change: The quoted announcement says the 5-hour usage limit will return for Plus accounts across ChatGPT Work and Codex. The stated reasons are to smooth compute demand while preserving generous weekly usage, and to prevent casual or new users from accidentally exhausting their weekly allowance and becoming confused. The $100 and $200 Pro plans will keep the 5-hour limit disabled for the coming months. Theo is relaying this announcement rather than sharing a firsthand coding-agent workflow or performance result.
Geoffrey Huntley reports a firsthand workflow: prompt the agent from day one of planning to create ADR skills, then have it recursively consult and maintain those ADRs during future development and planning sessions. This creates a persistent decision-record loop for agent context and project continuity.
- Toyota North America went from shipping one production agent every six months to shipping 50+ with Deep Agents and LangGraph; the linked case study is How Toyota North America put enterprise AI on the balance sheet with Deep Agents and LangSmith.
- Toyota’s quoted production-monitoring use case for LangSmith covers all agents, failed tool calls, pipeline-breaking PRs, and feature adoption, illustrating the observability needed to operate an agent fleet.
- Managed Deep Agents 0.6.0 automates the deployment work required to put an agent in Slack, with the release described as “Terraform for agents.”
- Armin Ronacher highlighted @tobi’s weekend implementation of a difficult systems project as an example of building hard things with AI. @tobi released walgit as open source after using Cursor’s “Git at Scale” post as the starting point.
- walgit is a single Rust binary that targets S3-compatible object stores, uses WAL and CAS primitives without another datastore, and implements
bundle-uriso large repositories can download quickly as chains of static bundles; it provides a familiar basic UX. Repository: https://github.com/tobi/walgit
@its_ao is recruiting dcode users to discuss planned features, share positive and negative feedback, and help improve the coding agent; direct messages are open.
Pi 0.84.3 enables PowerShell on Windows and should launch much faster on most systems because of bundling changes; release details: https://pi.dev/news/releases/0.84.3 Armin Ronacher adds that the startup improvement should be particularly noticeable on Windows.
-
Theo reports a scope-control failure with Opus 5: after being asked to review one specific PR, it ran the wrong
diffcommand and reviewed the five most recently merged PRs instead. Developers should verify the executed diff command and confirm the agent’s review scope matches the intended PR before trusting the result.