Quick Hits

• The day's clearest idea: agents stall when they grade their own homework. @RayFernando1337 surfaces a Factory article arguing the fix is an external "standard of completion"; @svpino relays PRAXIST, a product built around user-defined evaluators; @ericclemmons and @mattpocockuk push the same principle at the test level.
• MCP design split: @mxstbr says servers should expose their real tools because clients like Codex already provide tool search and code mode, while @parkerconrad's Rippling shipped an MCP server where agents write code to do the work and return only the answer.
• Token economics under scrutiny: @thdxr claims inference companies rent GPUs, charge 40%+ margins, and won't last; @morganlinton relays a lead engineer running most of his coding on two $20 DeepSeek plans; @NinaDSchick cites an OpenRouter estimate that agentic requests consume around 15x the tokens of human-led ones.
• @dhh amplifies @IntCyberDigest's retelling of Linus Torvalds pushing through a "debug session from hell," 24 debug patches and 18 kernel boots to find one round_up() that should have been round_down(), then letting the AI write the commit message.
• Pace check from @MikeBradleyAI: two models in a flash-tier ranking are 48 hours old, nothing over four weeks made the list, and the unified-memory hardware meta was rewritten within two days.

Write the Standard Before the Agent Starts

The most substantive cluster of the day says the same thing three different ways: define success outside the implementation, in executable form, before the agent begins.

@RayFernando1337 quotes Factory's article "What it Takes for Coding Agents to Complete Large Software Tasks," whose key line is that "the single agent didn't lack skill. It lacked a standard of completion." The recipe: a standard derived from the desired outcome, authored before implementation narrows attention, and kept current until the work meets it. Ray's own prediction, that Factory will "crack long running agents by the end of the year," is enthusiasm, not evidence.

@svpino covers PRAXIST Beta from @Sapient_Int, which productizes the same idea: you supply a measurable goal plus an evaluator, and parallel "Research Peers" explore competing approaches, share findings, and build across generations. The numbers circulating are vendor-reported with no methodology: 49 gold medals across 75 tasks versus 35 for Claude Code with Opus 4.8, at roughly $3K versus $38K in token cost, plus a claimed 100% safe-landing rate in a rocket simulation and SLAM error reduced from 9.37 to 5.01 centimeters. Interesting direction, unverified claims.

At the unit-test level, @mattpocockuk's suggestion to append "Tautological tests considered harmful" to CODING_STANDARDS.md so code review catches it got a memorable translation from @ericclemmons, who asked his agent to interpret: "Don't derive expected values by repeating the implementation. Test externally observable behavior against independently known expectations." Same principle, smaller scope.

@jamonholmgren's repost of @poteto fits the pattern from another angle: they ban comments in the grok bot codebase and built a skill to enforce it, on the grounds (the post cuts off mid-sentence) that agents misuse comments. Prose guidance gets ignored; executable standards get enforced.

MCP Servers: Expose Tools or Hand Over Code Execution

Two posts frame a live design disagreement about where composition logic should live.

@mikeldking flags @mxstbr's argument against the "nascent trend" of hiding MCP tools behind two generic tools, search and execute. His case: clients like ChatGPT and Codex already ship tool search and code mode, models are trained on them, and they work across every server. Making each server reimplement that layer forces the model to navigate a custom abstraction it was never trained on. His advice is to expose your actual tools and let capable clients find and compose them, with the caveat that this applies to clients that support those features.

@parkerconrad presents Rippling's newly launched MCP server, built by @callen_raveret's team, as the opposite bet: rather than repackaging "APIs built for humans," the server lets agents write code against Rippling and return only the result. One position centralizes composition in the client, the other in code the agent writes against the server. Both are argued from developer experience, and neither has settled anything yet.

Cheap Tokens, Shaky Margins, and the 15x Agent Bill

@thdxr's take on inference economics is blunt: token prices "could be a lot lower," but inference companies rent GPUs, serve tokens, and "slap a 40%+ margin on top." In his telling their advantage is only that they started early, and "i don't think they will last." Prediction, not reporting, but it lands alongside adoption stories like @morganlinton's, quoting @pidotdev: lead engineer Scott Fryxell moved most of his client work to DeepSeek via the Pi coding tool, paying for two $20 plans total and using Fable only sparingly.

Demand-side math comes from @NinaDSchick (amplified by @AmericanDebunk): data centers are "factories" producing intelligence, and OpenRouter estimates an agentic request already consumes around 15x the tokens of a human-led one. Her framing is that demand for useful intelligence has no obvious ceiling, so electricity demand forecasts built without industrial-scale AI were structurally wrong.

Supply keeps churning too. @MikeBradleyAI notes that in @TheAhmadOsman's ranking, GLM 5.3 Flash leads Qwen 3.8 Flash Next, then DeepSeek V4 Flash 0731, then Qwen 3.8 27B, with two entries under 48 hours old. That ordering is one poster's assessment, but the churn itself is his real point: blink for a few days and the leaderboard, and the local-inference hardware meta around unified memory, have moved.

Agents Meet Real Codebases: Kernels, Context Bloat, Orchestrators

The Linus story, via @IntCyberDigest and @dhh, is a useful antidote to both hype and dismissal: the AI repeatedly called the Intel GFX driver bug "impossible and unsolvable" and suggested writing a report instead. Torvalds kept going, and after 24 debug patches and 18 kernel boots found a single round_up() that should have been round_down(). He then delegated the commit message to the model. @dhh reads this as Linus "letting agents accelerate Linux"; the quieter lesson is that human persistence was the scarce resource.

Context hygiene gets a deep dive from @chasen_liao, who tested pi's built-in grep (an rg wrapper with a 100-result limit, 50KB truncation, and --hidden by default) and found a single "TODO" search dumping 30-plus flat lines into context. His fix is the @ff-labs/pi-fff plugin, which wires a native Rust search library into pi without subprocesses, adds frecency ranking, weights git-modified files, and paginates grouped results with a cursor. In his test, 33 hits returned as 20 grouped results plus a continuation cursor, which he says cuts first-screen noise by about 80%. All figures are the author's own benchmarks, but the underlying problem, search results flooding the context window, is real.

On the tooling layer, @MaxRovensky launched a native macOS orchestrator for Codex that uses a node canvas to pass context between agent tasks, moving "beyond a chat and a sidebar." @thekitze adds the wry footnote that Max shared it with the tinkerer.club community back in April, well before launch day.

Also in the Feed: Robot Ducks, Freed Terabytes, Hiring Calls

Off the AI beat but notable: @pollenrobotics opened orders for Microduck, a $399 bipedal robot you train in simulation and run on the hardware, with an open-source simulator already shipped and delivery promised before Christmas; @yacineMTB bought one immediately. @Cloudflare detailed five Rust optimizations to its DNS cache that freed 100TB of RAM across 250 billion entries, with inserts 43% faster and lookups 19% faster; @IntCyberDigest's framing that this "solved the global memory supply shortage" is cheerleading, the engineering is the signal. @GeoffreyHuntley relays @sloppenheimer's call for "top gun level" AI infra candidates, a reminder that labs are still hiring aggressively. Finally, @alex_prompter's self-repost promising "the best account on X" for watching production AI agents adds little beyond a pointer; nothing in it is verifiable.

Practical Takeaway

If you're delegating multi-step work to coding agents, the highest-leverage move supported by today's posts is to write an external, executable definition of done before the agent starts: tests that check externally observable behavior against independently known expectations, or an evaluator script the agent must satisfy, kept current as the work evolves. Both the Factory article and the tautological-testing thread argue that agents without such a standard converge on plausible-looking output rather than correct output. If your agent stack includes MCP servers, it's also worth auditing whether they expose real tools or hide them behind a generic search-and-execute layer, since @mxstbr's argument implies the former works better with clients trained to compose tools directly.