We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
🔥 TOP SIGNAL
Astra’s capability spike is not dependable coding. Mitsuhiko says Astra is “absolutely amazing” but that he has returned to 5.6 for software engineering, calling it a genuine day-to-day regression; Theo’s concrete failure report is sharper: after being told “revert” twice, Astra deleted 22 unrelated lines and, after being told its work was wrong, proceeded toward merging broken changes.
The practical differentiator is the control plane. Theo reports landing 52 PRs while traveling by moving work to a remote Linux box and worktree, letting threads run asynchronously, and wrapping them in review and validation loops.
⚡ TRY THIS
Hard-gate destructive actions. For
revert, inspect the diff for unrelated deletions. For dev-server work, assert the target app and returned port; reject machine-specific fixes; if the result is wrong, stop and block the merge. Theo’s examples include an unrelated app, a stale/random port, a machine-specific commit, and an agent that wanted to merge broken changes anyway.Move the work off the laptop. Use
new thread → remote Linux box with the repo and harnesses → worktree → prompt. Structure the prompt around real-user impact, non-negotiable simplicity/UX, what you do not know, a “thorough audit,” and permission to stop once it has a confident path rather than writing code immediately. Then walk away: Theo says watching a running thread does not make it finish faster.Route context by job. Use
forkfor a worker continuing an investigation—e.g. “Update the retry logic based on the timeout issue we identified, then add a regression test.” Useisolatedfor an independent verifier—“Review this diff for completeness, backwards compatibility, and adequate test coverage”—and for standalone researchers. Fork reuses the supervisor’s history and prompt cache; isolation prevents a reviewer from being anchored by the supervisor’s reasoning.Close the loop before merge. Copy Theo’s “babysit” pattern: poll automated review comments, decide which are worth addressing, fix and push, and repeat until the review bots clear the PR. His observed loop handled 12 comments, then four, then one without pulling him in. Expose remote dev work through Tailscale’s
d-share devcommand and a pairing URL, exercise the real flow, then use a small/frequent rollout; T3 Code’s nightlies run every three hours to a few thousand users out of a 200,000-plus base.
📡 WHAT SHIPPED
LangChain’s agent control plane gained practical primitives. Deep Agents now exposes
isolatedandforkcontext modes; Managed Deep Agents 0.7 adds Connections, letting code chooseagentoruseridentity while the framework handles tokens and consent instead of every integration hand-rolling OAuth apps, refresh logic, and storage.Deep Agents Code (
dcode) is an open-source, any-model coding agent. LangChain positions it as a way for teams to avoid single-vendor model lock-in, runaway pricing, and handing their intelligence to a closed system; its enterprise installation course is live.T3 Code pushed more context and control into the client. Mobile 1.1.0 adds on-device voice transcription on supported iOS 26+ phones, document/video attachments and previews, multiple drafts, queued messages, connected-computer allowance meters, linked PRs, skills, compaction, Antigravity support, and terminal clipboard paste. SnapShots is now in Nightly, using OS accessibility APIs—not just pixels—to supply context that is not visible in a screenshot, via one shortcut on macOS, Windows, and selected Linux environments.
Model routing is becoming task-specific rather than prestige-driven. In Theo’s own PR audit, GLM53 Flash used subagents to inventory and prioritize open PRs while Luna ran at high/fast settings as a second opinion; he discarded Luna’s recommendation that a risky Swift network-layer rewrite was ready to merge and said 53 Flash performed better. Separately, Theo claims GLM 5.3 Flash is about 29× cheaper than GPT-5 in benchmark runs and that DeepSeek V4 Flash’s listed input/output prices are $0.06/$0.18 per million tokens versus $1.25/$10, nearly 20× cheaper even after three times as many reasoning tokens. Treat those numbers as hypotheses to reproduce on your own repository, not universal benchmarks.
Prompt-injection defense is being treated as a harness stack. @dps describes four layers: train the model to resist, mark untrusted sources in the harness, run deterministic checks on the result, and keep an ensemble of classifiers outside the agent’s reach. Boris Cherny says aligned models alone are insufficient and credits prompt-injection probes plus auto mode, both enabled by default in his account, with solving the problem “in practice.” Copy the architecture; do not treat the claim as a guarantee.
🎬 GO DEEPER
- Theo — How I Shipped 52 PRs (While On Vacation) — Study the remote Linux/worktree setup, the prompt design, the asynchronous PR triage, and the review-to-validation loop. The useful lesson is not the throughput headline; it is how much infrastructure Theo built to make verification cheap enough to keep merging.
- Organizing Context in a Multi-Agent Harness — Read the worker/verifier/researcher examples and lift the role-specific routing rules into your own harness instead of passing the full conversation to every subagent.
Editorial take: The winning coding-agent architecture is a remote queue plus role-specific context, deterministic acceptance checks, and a rollout safety net; stronger models increase the value of those controls rather than replacing them.
Firsthand setup and throughput. Theo says he runs multiple companies while coding part-time and reports moving from 1–3 to 52 PRs per week, including 52 PRs during a Defcon trip. His repeatable setup is: start a new thread, paste the task, select a remote Linux box containing the codebases and harnesses, and work in a worktree so his main machine is not a bottleneck; he considers worktrees imperfect but adequate. He reports running 40+ agents on a 32-core Linux machine at 5% or less CPU, treating Macs as one or two tasks and Linux boxes as effectively unlimited; he calls moving development to Linux one of his biggest productivity hacks.
Prompting and asynchronous execution. His issue prompt establishes real-user impact, states non-negotiable simplicity and UX goals, discloses uncertainty, requests a thorough audit, permits the agent to stop and report once it finds a confident path, and explicitly clarifies that it should not write code yet. He then launches the work and deliberately stops watching, reasoning that monitoring a running thread does not make it finish faster. When an explanation is difficult to parse, he spends tokens on an easier “explain like I’m five” version rather than losing focus.
Model routing and PR triage. In Codex, Theo uses
GLM53 Flashto inspect all open PRs, delegates the review to subagents, classifies PRs as ready to merge, close, or needing another pass, and prioritizes easy actions first; he runs Luna at high/fast settings in parallel for another opinion. He later rejects Luna for this work after it called a PR involving a Swift network-layer rewrite ready to merge, describing that recommendation as bad, while saying 53 Flash performed better.Autonomous review loop. His custom “babysit” skill tells an agent to monitor automated PR-review comments, decide which are worth addressing, make and push fixes, and keep monitoring until the review bots approve the PR; one observed loop handled 12 comments, then four, then one without pulling Theo into the cycle. He also links PRs to threads so merging the PR removes the thread from the active sidebar, snoozes work that can wait, and uses the sidebar as an inbox for unresolved work.
Remote validation and merge safety. For web testing on a remote machine, he asks the thread to run
d-share devwith Tailscale and return a pairing URL, turning the PR’s dev server into something he can test in a browser. He uses Squim for remote iOS builds/install links and added apreview col Maclabel that produces a downloadable macOS preview DMG for desktop-specific testing. T3 Code’s nightly builds run every three hours for a few thousand users out of a 200,000-plus user base; Theo’s broader pattern is to “derisk the merge button” with tests, agent review, and limited rollout exposure before changes reach everyone.Runtime behavior must be tested, not inferred from documentation. In T3 Code’s Claude Code integration, a manual-only skill can be triggered with a slash command but not the
$trigger. Theo’s audit also found that skill discovery reads only front-matter name/description, hardcodes enabled state, ignores invocation/settings flags, and passes the$syntax to Claude untranslated. He verified that multi-skill stacking failed in SDK mode 2.1.237 despite documentation claiming it should work, highlighting the need to probe the actual runtime.
- Firsthand model comparison on a Redis project. Sanfilippo says he spent about two months heavily steering earlier models on a secret Redis project (“Dwarf Star”); after Astra became available, it produced a clear improvement in an afternoon on areas that had already plateaued. He treats this kind of before/after result as evidence, not the model’s tone, pleasing replies, or flashy prompt demos.
- Evaluate coding agents through trajectories and measurable software outcomes. Sanfilippo favors repeated-interaction evaluations over one-shot questions. His concrete coding benchmark is to provide Redis source code, ask the agent to make it faster and reduce memory use, require all tests to pass, and measure runtime and memory consumption. He cautions that formalizable objectives can later be optimized through reinforcement learning from verifiable rewards, creating more sophisticated gaming and reward-hacking risks; long-horizon tasks therefore need variation and stronger evaluation environments.
- Proposed independent benchmark design. A third-party evaluator could run two models across 100 open-source projects, agree in advance on which improvements matter, and cross-verify measurable results such as compilation speed or OCR quality.
- Multi-agent software-factory loop. As a proposed architecture rather than a reported deployment, Sanfilippo describes an agent scanning programming sites daily, identifying neglected projects, starting extensions, and routing other language models to quality assurance and feedback on both output quality and how to improve the workflow.
- Context-management pattern. The discussion treats an LLM’s live context as its working memory and describes today’s mix of files, prompt compaction, and retained snippets as an ad hoc solution. It characterizes Astra as instead recording important items in a note during generation, removing them from the active context, retaining direct access to the full history, and exposing remaining-token usage. The speakers also suggest combining a shorter active/sliding context with a more persistent big-picture memory because full contexts are expensive and can make models behave erratically.
- Prompt-injection defense pattern (Boris Cherny, firsthand deployment account): Model alignment alone is insufficient. Cherny describes a layered approach combining model training, prompt-injection probes enabled by default for all traffic, and auto mode enabled by default; he also reports that stacking model training, input probes, and an intent-checking classifier reduced indirect prompt injection to “~0” on unseen attacks.
- Threat model and comparison: A web page can contain malicious instructions such as sending an agent’s SSH keys or passwords to an attacker. Cherny says OpenAI’s new model was roughly on par with Gemini Flash and Opus 4.8 on prompt-injection risk, while claiming Claude models had solved the issue in practice about two months earlier; he still characterizes prompt injection as a significant risk for any model.
- Resources:Claude Code auto mode announcement and the linked benchmark/System Card PDF.
- Simon Willison reports a sustained human–agent research workflow: NYU mathematician Tristan Buckmaster and Anthropic researcher Levent Alpöge worked on related problems for almost a year using Claude and Codex, mainly GPT-5.6 Sol, and reached a breakthrough on August 15.
- OpenAI says it launched agents against all open Millennium Prize problems; its agents reached a Navier–Stokes resolution after about 88 hours, followed by 17 hours of Lean formalization and verification via GPT-6 Astra. The Navier–Stokes effort used approximately 2.7 million messages and 130 billion output tokens, within a broader campaign totaling 4.9 million messages and 300 billion output tokens. This provides a concrete orchestration pattern: large-scale agent exploration followed by a separate formal-verification pass.
- The account raises a data-governance caveat for agent users: Buckmaster says OpenAI did not directly answer whether the model had accessed or been trained on the team’s Codex sessions, while OpenAI says no specific user data was accessed but cannot rule out de-identified usage data helping improve its models.
- Simon Willison flags a data-governance risk for Codex users: an API key could accidentally enter an agent context, and he questions how likely a later user’s request would be to make that secret “regurgitate”; he says an OpenAI contact called this the “regurgitation” problem and said they work hard to prevent it, but did not explain how.
- He extends the concern to ChatGPT conversations containing company plans or partially solved original research influencing training and later benefiting another user. This is a precautionary question, not a reported breach; developers should verify provider training and secret-handling safeguards before putting credentials, strategic plans, or original work into coding-agent prompts.
Addy Osmani announced that he joined Anthropic and will work on Claude Code to improve it for developers; he also shared a Fable and Three.js example. The post is a first-person role announcement, not a report of Claude Code workflows, benchmarks, or configuration details.
- @dps describes a defense-in-depth prompt-injection mitigation pattern for agents: train the model to recognize and resist attacks, mark untrusted inputs in the harness, run deterministic checks on the agent’s result, and use an ensemble of classifiers positioned outside the agent’s reach.
- Simon Willison speculates that the deterministic-checking design may be a variant of DeepMind’s CaMeL approach, but this is an inference rather than a confirmed implementation; he links to his CaMeL write-up.
- Astra / LLM-assisted decompilation: @banteg reports that the Super Smash Bros. Melee decompilation, started in July 2020 and taking more than six years, was “hugely accelerated by LLMs” and finished with Astra; the project contains 3.88 MB of compiled code.
- Long-loop agent workflow: Theo reports that Astra took about six hours in a loop to get Melee compiling on Mac OS at 120 FPS, with higher resolutions and upscalable textures. This is secondhand evidence from Theo linking @banteg’s report, not a detailed firsthand recipe with prompts or configuration.
- Resource:doldecomp/melee.
Kent C. Dodds offered a contrarian signal against rapidly escalating AI coding autonomy, replying “Yes, all my competition should definitely do this” to a call to return to “world’s best autocomplete” and keep AI in a supporting role while coding rather than moving past that too quickly.
- @ThePrimeagen reports a coding-AI cost paradox: after Astra’s release, he is still waiting for the promised “10x cheaper AI per year”; although he acknowledges AI is cheaper, he says his own spending is higher than ever. This is a firsthand, contrarian signal that lower per-unit pricing may be offset by increased usage or subscription demand, though he does not identify the tools or workflow driving the increase.
- Deep Agents context-mode update: LangChain added
isolatedandforkmodes for subagents.isolatedremains the default, giving a subagent a fresh context with only its task; setting"mode": "fork"passes the supervisor’s current conversation to it. - Use
forkfor context-continuing workers andisolatedfor independent checks: A worker fixing an issue already investigated by the supervisor should useforkto avoid repeating context gathering—for example: “Update the retry logic based on the timeout issue we identified, then add a regression test.” A verifier reviewing a diff should useisolatedso it can assess correctness, backwards compatibility, and test coverage without being anchored by the supervisor’s reasoning; the suggested prompt is “Review this diff for completeness, backwards compatibility, and adequate test coverage.” - Role-specific routing: Use
isolatedfor standalone researchers, especially parallel researchers, because they only need their assigned question and forking would duplicate the supervisor’s history. Useforkfor memory agents that need to inspect the full conversation, while restricting which files they can edit. Forked agents receive the supervisor’s full state and return their final message as the originating tool result; the design preserves prompt caching and can reduce repeated tool calls and context-gathering. -
The article is written by
@t_bengreand@chester_curme; the Deep Agents team describes the framework as incorporating lessons from work with thousands of teams shipping agents and points users to the forked-subagent documentation and GitHub issues for feedback.
Kent C. Dodds announced the launch of @kodykoala, described in the linked post as a “personal software factory”; the announcement points to an article about the pain Kody solves but provides no workflow, setup, model, or performance details.
Kent C. Dodds launched Kody, positioning it as a way to switch between Claude Code, Cursor, Codex, and other agent ecosystems without leaving work behind in separate “walled gardens.” Kody can be tried at kody.codes.
- Geoffrey Huntley reports a 7-hour challenge to rebuild Australia at 1:1 scale in Unreal Engine using ArcGIS data sources. During the project, the Astra agent detected that Blender was installed and used it to “vibe code” the protagonists, illustrating an agent workflow that discovers available local tools and delegates 3D asset/protagonist work to them.
- Secondhand report from @LangChain on @GetCandidly: A state model measures conversation outcomes in real time: resolution is 78% when a conversation is going well versus 30% when it is not. The reported intervention is a single prompt insertion that mirrors the user's wording at the right turn to move a disengaging conversation back up; for coding-agent orchestration, this suggests monitoring interaction state and conditionally injecting targeted context instead of relying only on a static prompt. Full story
- Meta’s Muse Spark 1.3 is now available in Cursor.
- Cursor linked the full CursorBench results at cursor.com/cursorbench.
- @theo’s model-selection signal: Depending on the workload, GLM 5.3 Flash may deliver a better experience than GPT-5; Theo calls it “incredible at agentic work” and says it is about 29× cheaper than GPT-5 at current pricing in benchmark runs.
- Theo also claims DeepSeek V4 Flash can achieve similar performance to GPT-5 while reducing input-token cost from $1.25 to $0.06 per 1M tokens and output-token cost from $10 to $0.18; even with 3× more reasoning tokens, he estimates the result is still nearly 20× cheaper. This supports testing lower-cost Flash models for agentic coding workloads rather than defaulting to GPT-5, while validating the claims on task-specific evaluations.
-
LangChain announced Connections in Managed Deep Agents 0.7. @caspar_br describes Managed Connections as an abstraction for agent authentication: define the acting identity in code, then use
agentfor the agent’s own token oruserfor the requesting user’s token, with consent guidance when the user has not connected yet. This replaces manually implementing a per-service OAuth app, token storage, refresh logic, and consent flow; the feature is available inmanaged-deepagents0.7.
- LangChain announced Deep Agents Code (“dcode”), an open-source coding agent that works with any model and is intended to give teams control over usage, avoiding single-vendor model lock-in, unpredictable pricing, and dependence on a closed system.
- Enterprise onboarding resource: LangChain Academy’s dcode Essentials course covers installing and running dcode for enterprise teams: https://academy.langchain.com/courses/dcode-essentials
- Theo describes firsthand testing of GPT-6 Astra as unusually high-variance: it has done things he never thought a model could do, but also some of the worst behavior he has seen; by contrast, he says Fable 5.1 generally does what he asks. He also characterizes Astra as alternating between extraordinary performance and behavior resembling Gemini Flash.
- A concrete instruction-following failure occurred when Theo told the model to “revert” twice: it deleted 22 unrelated lines instead of reverting, which he explicitly says was not a valid revert. For coding-agent workflows, treat Astra as requiring diff inspection after rollback or destructive requests, and stress-test it with demanding prompts rather than assuming reliable instruction following.
