We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
Turn your agent's tool failures into an eval, then hill-climb
Theo says agents now use T3 Code's tools "4x better while using 79% less context" . T3 Code's tool surface had grown with the built-in browser, mobile device manager, subagents and delegates, so he built an eval from how his agents actually used the tools, including "all the failures and rage moments." It has over 80 cases, and Opus failed more than half of them at the start . His loop is one you can copy for your own MCP servers or tools:
- Benchmark a cheaper model (Sonnet 5.5) and keep changing tool descriptions until it gets a perfect score.
- Add Sol, then Opus, and do the same for each.
- Merge once error rates improve.
- In a new thread, tell Opus to cut context use by 50% with no regressions on the eval, then ship .
He says this "shape" is close to the one he used for his earlier UI-overhaul hill climb . He also posted that the run cost about $1,500 in tokens.
The result shipped in T3 Code 0.1.3, which brings stable up to date with nightly. In this release, T3's agent instructions are 60% shorter, MCP tool schemas are a third smaller, and "steer" replaces queueing as the default. Opening a thread loads 85% less data, guest sharing takes two clicks, and T3 Connect switches to LAN when other machines are on the same network .
Theo's skills, now public as tstack
Theo is publishing his skills at t3dotgg/tstack . A walkthrough video explains three of them:
- Descriptions are triggers. A skill's description should say when to use it (for example, "use when the user says Soul Loop"), not what it is . When an agent misbehaves, he asks it why and then patches the skill .
- Review loop with a budget. Opus writes the code and GPT-6.1 Sol reviews it. The skill says to make minimal changes, watch for scope creep, and push back when a finding is wrong. Three rounds at most: the first is a full review, and later rounds check only changed code and open findings. It can go to five rounds for security, permission or data-loss risk, and stops early if only nits remain. Only one reviewer runs at a time, with no nested subagents . The PR must report the reviewer's verdict, because he noticed Opus "almost wants to hide" disagreement .
- "Full send" and "full stop." Full send hands the agent everything up to a merged PR. It explicitly grants merge and force-with-lease permission, which he added because OpenAI models hesitate to merge without it . The agent must show proof it observed itself: reproduce the failure, fix it, see the reproduction pass, run the repo's CI checks, and add one focused test . The merge gate requires proof covering every change, green required checks, every bot finding fixed or dismissed in writing, no open human change requests, and a branch that is up to date and mergeable . In a recent window, 27 of 32 full-send threads merged without him looking again . Full stop does everything except merge, for riskier changes .
Theo also tells users not to add multiple accounts directly to T3 Code. He uses a CLIProxy fork to share 7 Claude and 3 Codex subscriptions across 12 machines , and posted a setup gist you can give to an agent . He warns that Anthropic expects Claude subscriptions to be used only with the Claude Code system prompt .
Models and tools
- GPT-6.1 Terra (OpenAI): pitched as fast computer use at a lower price . OpenAI's Tibo says it gives 2× more usage than 6.1 Sol across API and subscriptions, with better writing and understanding of requests . Greg Brockman says it feels faster at using a computer than he is unassisted .
- Cursor Agent SDK: define agents as code, with prompts in Markdown and tools in TypeScript, then run them on Cursor's hosted infrastructure or your own. Evals are built in .
- DeepSeek V4.1 Flash in Cursor: Cursor says every effort level is on the CursorBench cost frontier at $0.60–$0.98 per task. Turn it on under Settings > Models .
- The harness changes results: a posted evaluation found the Pi harness ended Gemini 4 Argon runs on fallbacks in 20% of cases. Rerun in the Antigravity harness, Argon beat Astra and came just behind Opus 5.5 . Check the traces before you trust a model comparison.
- Theo's picks: his "realistic pareto line" is GPT-6 Luna, GPT-6.1 Sol and Opus 5.5 . He says Muse finds bugs Opus misses and writes prompts and skills better .
-
Claude Code:
--dangerously-skip-permissionsstill blocks things likerm -rf ~. A new env var,CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1, turns that last block off .
How much human in the loop?
Brent Traut argues unit tests give agents little safety because "AI just changes all the unit tests anyway" . When replies said to keep test changes separate from code changes, he questioned whether people really have humans reading or writing every test . He says improving loop automation is "extremely leveraged work" . Theo's proof requirements and merge gates are one concrete version of that automation.
Addy Osmani's rule for subagents: keep one only if the work is parallel, needs fresh context, or one agent can't pick the right tools. Otherwise, move its prompt into a skill, fold it into the main loop, and run evals .
Shorter notes
- Billing watcher: Anj Nanda suggests an always-on agent, which can be Claude Code, that checks transactions and logs every 30 minutes, fixes problems and messages you. He says it prevented at least three incidents and $30,000 in losses for about a $200 subscription .
- Entire: a new Git forge for agent-human collaboration . Jason Zhou says linking agent sessions to commits is "such an unlock" .
-
Managed Deep Agents 0.9 (LangChain): agents can create schedules, each run can pick its model, skills and tools, and agents react in Slack before replying . The
mda init/mda dev/mda deployCLI scaffolds, runs and ships agents . - Token costs: Theo says cached reads and writes make up most of his Opus spend, while plain input and output tokens are under 8%. That makes total token counts a poor estimate of cost .
-
Bun AOT:
--trimshrinks a macOSBun.servebinary from 89 MB to 25 MB . Peter Steinberger reports 2–3× better performance and less than half the memory .
- Keep an always-on agent checking billing infrastructure, transactions, data, and logs every 30 minutes; have it investigate and fix suspicious activity, then notify you. The practitioner reports this setup prevented at least three issues and at least $30,000 in losses, for about a $200 cloud subscription . The speakers also recount exploiters running up roughly $100,000 in API costs using free credits, while saying no user data was lost and they were not hacked .
- For API-key handling, use 1Password service accounts to store pointers to keys instead of the keys themselves on your server; this does not prevent a compromise, but makes keys easier to restrict afterward .
- For app-building agents, the practitioner notes that developers commonly override Supabase security rules and recommends explicitly prompting the AI to secure the app .
- Theo cautions that aggregate token totals are poor proxies for inference spend: cached reads, cached writes, and ordinary input/output have different prices; in his Opus usage, cached reads accounted for about half his cost while ordinary input/output accounted for under 8%.
- Theo says agent workflows changed his view of tool use: he once dismissed asking models to run commands, but came to see tools and bash as central to their work. In his bug-fix example, instead of manually locating and editing code, saving, restarting the dev server, and checking the browser, he now gives the model a screenshot and asks it to fix the bug; the task may cost a similar amount while removing that manual effort.
- Theo reports that Lauren runs deep agent sessions and files thousands of PRs a month; he says she power-uses Cursor and Grokbot to give feedback and improve the products, framing the work as more than code output alone.
- In a sponsored segment, Theo recommends Depot for agent-heavy workflows: its programmable CI supports parallelizable work, while its cache supports monorepos and shares Docker build artifacts across a developer, team, and CI.
- In Leash Bio’s medicinal-chemistry setup, each language-model agent gets a target, a catalog, and a budget of 100 molecule tests; it states structure–activity hypotheses and tests them against a premeasured landscape. The team reports about 90,000 rollouts, enabling comparisons across agent search policies.
- Evaluating the search process—not just the final result—revealed agents that give up early, repeat tests, or select molecules inconsistent with their hypotheses. More performant models abandon unproductive neighborhoods faster; weaker ones keep making small changes around low-scoring molecules.
- A reusable evaluation pattern is to measure an environment once and replay many agent rollouts, trading the flexibility of live experiments for a choice set limited to what was measured. Leash said it planned to release environments and thousands of transcripts for others to inspect agent behavior.
- Theo turns repeated practices into skills with explicit trigger descriptions, then revises them when agents make mistakes. His review loop limits reviews to three rounds (first a full review, then only changed code and open findings), extends to five only for security, permission, or data-loss risks, and stops if only nits remain; he also uses one reviewer at a time and aims for minimal changes to prevent scope creep.
- At recording, T3 Code’s Orchestrator V2 was in nightly and let threads delegate reviews to agents running in their native harnesses. Theo says multiple models can surface different issues; in his experience OpenAI models were most thorough, Claude found unusual potentially dangerous issues, and Gemini hallucinated more often.
- His opt-in “full send” workflow gives the agent ownership through a merged PR. He explicitly grants merge permission, requires direct proof (such as reproducing the original failure and confirming the fix, plus repo CI checks and a focused test where appropriate), and gates merging on green required checks, resolved or explicitly dismissed bot findings, no outstanding human change requests, and an up-to-date, mergeable branch. In a limited recent sample, he said 27 of 32 full-send requests merged without him revisiting them; he cited six-hour nightly releases and rapid feedback as safety nets.
- For riskier changes, “full stop” follows the same hands-off approach but never merges: the agent verifies and reviews the work, handles CI and review feedback, and alerts Theo only when blocked or when the PR is ready for him to merge.
Anthropic said Claude wrote over 90% of contributions to its codebase in September 2026; it also reported that the monthly value of internal Claude usage first exceeded monthly personnel expense, excluding stock-based compensation, in April 2026. Claude is also used in many aspects of research, training, and testing for subsequent model generations.
Kylon advertises a shared-context agent workflow for internal apps: an agent builds with context from a shared room, teammates mark up the result, the agent revises it, and a person signs off before shipping.
- Moonshot described Kimi K3.1 as a 3-trillion-parameter open-weight model and said it would be downloadable on November 4, while the presenter flagged that timing as uncertain. It was reported within one point of Opus 5.5 on Terminal-Bench 4.0, and Artificial Analysis measured 67%, the highest score among models it tested; benchmark results can vary substantially with the harness. Kimi also reportedly led on the S. Marathon multi-hour software-requirements test.
- For cybersecurity coding, Moonshot said it removed cybersecurity data from training: its internal unfiltered checkpoint scored 90.5% on its illegal-exploit tests, compared with 81% for the final release.
- A sponsored Mobbin MCP workflow lets coding agents such as Claude Code and Cursor consult a library of 600,000 UI screens, collect references into a visual report of shared patterns, then recreate and adapt a flow for an app; results link back to their original screens.
Claude Code’s --dangerously-skip-permissions still blocked obvious commands such as rm -rf ~; the new opt-in environment variable CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1 disables that remaining block. @swyx praised shipping the choice rather than deciding on users’ behalf.
Anj Nanda recommends an always-on agent, including Claude Code, to monitor billing infrastructure, transactions, logs, and other data; check every 30 minutes and have the agent fix problems and send an alert, with API-key and billing abuse a key focus. He says his team’s setup prevented at least three issues and $30,000 in losses.
Addy Osmani’s rule of thumb: before adding a subagent, identify the problem it solves—an oversized system prompt may be the real issue. Try skills or tool search instead when they can address it without splitting context; keep a subagent for parallel work, tasks needing fresh context, or cases where one agent cannot choose the right tools. Otherwise, fold the work into the main loop, turn the subagent prompt into a skill, run evals, and keep the approach that performs better.
Ben Vinegar’s takeaway: coding agents can help teams ship faster, but developers should keep human judgment in the loop to decide what is worth shipping.
Kent C. Dodds says Kody is not an agent; it is a place an existing agent can put information the user does not want locked in a walled garden, positioning it as a complement to coding agents rather than an agent itself.
Peter Steinberger tested Bun’s AOT compiler over a weekend and reported 2–3× performance and less than half the memory use, though the post gives no benchmark details . Bun’s --trim option removes unused components; the quoted post says a macOS binary using Bun.serve shrank from 89 MB to 25 MB .
Huntley recommends creating many small bots and piping them together, using POSIX/Unix composition as the model; he describes this approach as reactive-stream programming.
Kent Dodds says people are beginning to understand the problem Kody solves by experiencing it . The linked post describes agent portability as having gone from “nice-to-have” to a “disaster recovery plan” .
- LangChain’s Deep Agents approach treats an agent as a model plus a harness—skills, memory, and system prompt—to provide the right context at the right time. For code-capable agents, the reusable design pattern is filesystem-backed execution with a sandbox, progressive skill disclosure and context compaction (including offloading large tool outputs to files), task delegation to subagents, and human approval gates.
-
Separate agent development into business logic, harness, and production infrastructure; Managed Deep Agents couples the harness with LangSmith Deployment and supplies durable execution, task queues, MCP/A2A orchestration, sandboxed code execution, and governance, tracing, and evals. The concrete workflow is to scaffold with
mda init, define the agent in TypeScript or Python plus its instructions, skills, tools/MCP connections, auth/identity, and memory, run locally withmda dev, then deploy withmda deploy;mda evals initcan use an interactive setup to configure Harbor environments and checks for iterating on eval datasets and experiments. - Make credentials and memory depend on the caller and channel: pass the identified user into runtime context, choose user-scoped or agent/service-account credentials, and use personal memory in private contexts but agent-scoped credentials in shared channels to avoid exposing private information. Durable execution can pause for authorization and resume the same run later, even after several days.
Theo reports that T3 Code agents now use its tools “4× better” while using 79% less context.
- To improve T3 Code’s tool schema and descriptions, he built an eval from day-to-day agent usage and failures; it had over 80 cases, and Opus initially failed more than half.
- His iteration sequence was to tune descriptions until Sonnet 5.5 scored perfectly, repeat with Sol and Opus, then ask Opus in a fresh thread to cut context use by 50% without eval regressions before shipping.
Jason Zhou says his team has been using GoEntire in part of its codebase and calls connecting agent sessions to commits “such an unlock,” highlighting the value of linking agent work with the commits it produces. The launch post describes Entire as a Git forge for agent-human collaboration and says GoEntire was built using it.
T3 Code 0.1.3 is live, with stable caught up to nightly. The release makes T3’s agent instructions 60% shorter, MCP tool schemas a third smaller, and “steer” the default instead of queueing. Opening a thread now loads 85% less data, and cold connects send up to 93% less.
A developer introduced T3 Tots, a Grok bot companion for T3 Code, describing it as handling routine work and surfacing only items that need human attention; they report intensive use and increased productivity, especially when working across multiple computers.
Theo said T3 Code is overhauling its MCP and environments layer to make this kind of workflow easier, and asked how the developer manages connections to multiple environments. He called the current approach “very dangerous” and said a safe version is coming soon.
Cursor added DeepSeek V4.1 Flash; it says every effort level is on the CursorBench cost frontier at $0.60–$0.98 per task, with no model scoring higher. Enable it under Cursor Settings > Models.