Twitter AI Agent - 2026-07-09¶
1. What People Are Talking About¶
1.1 Benchmarks shifted from model wars to harness economics π‘¶
The most concentrated discussion on July 9 was not simply about which model was smartest. It was about which model-plus-harness combination delivered the best result per task, at what cost, and with how much operator friction. At least five distinct items pushed the conversation from leaderboard bragging toward cost, routing, and workflow design.
@danshipper argued (649 likes, 42 replies, 108,379 views, 395 bookmarks) that GPT-5.6 Sol is cheaper, faster, and easier to use than Claude Fable 5, but still trails Fable at the hardest coding tasks: his team scored Sol at 56/100 versus 91/100 for Fable on an internal senior-engineer benchmark. The distinctive angle was operational rather than ideological. He recommended using Sol as Fable's subagent, and a reply said the more important product change was workflow compression once chat, repo state, browser checks, and review live in one desktop surface.
@ArtificialAnlys reported (674 likes, 22 replies, 34,448 views, 105 bookmarks) that GPT-5.6 Sol came within one point of Claude Fable 5 on its Intelligence Index while costing about one third as much per task, and that Sol in Codex led its Coding Agent Index at 80. The attached chart mattered because it made the tradeoff visible: near-parity on general intelligence, better coding-agent placement inside Codex, and a materially different cost curve.
@databricks said (23 likes, 1,682 views) its real-task benchmark across a multi-million-line codebase found that token pricing is a poor proxy for real-world cost, that open and proprietary models both appear in the top tier, and that harness choice can materially change both price and quality. That is a stronger claim than a typical model launch thread because it is grounded in real engineering tasks instead of short synthetic prompts.
@RoundtableSpace claimed (48 likes, 15 replies, 45,057 views) that a pre-write gatekeeping system called Ponytail cuts token use by 20 percent and improves terminal execution speed by 27 percent by forcing the model to ask whether the feature already exists, whether a library can solve it, and what the minimum viable code change is. @Vtrivedy10 added (20 likes, 1,319 views, 21 bookmarks) the enterprise version of the same logic: start with harness engineering, move to fine-tuning only after you hit the ceiling, then come back to harness engineering once the model changes.
Discussion insight: The replies were about workflow shape, project separation, token burn, and task fit more than raw frontier-model fandom. Readers were trying to decide how to buy intelligence efficiently, not just admire it.
Comparison to prior day: July 8 already treated harness and loop engineering as the place performance gains live. July 9 pushed that one step further into cost-per-task charts, live codebase benchmarks, and explicit gating heuristics.
1.2 External verifiers and correction memory became part of the product loop π‘¶
A second cluster treated self-improvement as a systems problem: capture what the user corrected, score trajectories with something outside the agent, and rewrite the failing component instead of trusting the model to just "do better next time." At least four items contributed distinct evidence here.
@clairevo showed (203 likes, 10 replies, 19,864 views, 268 bookmarks) a custom harness built with ClaudeDevs SDK to triage Sentry bugs, verify root cause, and ship fixes. The useful part was not the slogan "it's the harness, not the model" but the concrete pipeline: bug intake, verification, then shipping. A reply sharpened the idea by reducing the harness to "everything except the engine," while another warned that over-outsourcing judgment can become its own failure mode.
@free_ai_guides mapped (9 likes, 464 views, 12 bookmarks) a self-learning loop where agents learn from both their own traces and the user's fixes, then store lessons as facts, cases, and rules. The diagram is the key evidence because it makes the memory model explicit and keeps loop ownership outside the agent.
@jackyk02 introduced (32 likes, 3 replies, 70,251 views) LLM-as-a-Verifier, using finer-grained scores, score-token logprobs, and repeated evaluation to produce stronger signals for test-time scaling, reinforcement learning, and monitoring. The attached image mattered because it published concrete benchmark numbers, including 86.5 percent on Terminal-Bench V2 and 78.2 percent on SWE-Bench Verified, instead of leaving verification as an abstract recommendation.
@ArchiveExplorer summarized (17 likes, 3 replies, 954 views, 14 bookmarks) a Fudan harness-engineering paper where every tool, prompt, and skill becomes an observable contract; an outer loop rewrites the component that failed; and any regression is automatically reverted. The distinctive angle was that the model weights stay frozen while tools, middleware, memory, and skill files do the improving.
Discussion insight: The common pattern was that the loop owner lives outside the agent. Sometimes that owner is a verifier, sometimes a memory layer, and sometimes a second agent that edits only the broken part of the harness.
Comparison to prior day: July 8 repeatedly argued that verification has to be separate from instructions. July 9 turned that principle into concrete memory taxonomies, verifier scorecards, and contract-based rewrite loops.
1.3 Skills looked more like reusable infrastructure than prompt craft π‘¶
The "skill" conversation continued to move away from giant prompts and toward portable, installable, and independently maintained units of expertise. The evidence came from open repos, a vendor catalog, and a mainstream framework release.
@MengTo recommended (21 likes, 2 replies, 2,023 views, 35 bookmarks) pairing two open-source repositories: mattpocock/skills for engineering skills and davidondrej/skills for agent orchestration. The repo pages sharpened the distinction. Matt Pocock's collection emphasizes small, composable engineering skills for "real engineering," while David Ondrej's organizes reusable workflows for orchestration, research, docs, and ops.
@dotnetfdn announced (4 likes, 385 views) that Agent Skills for .NET has moved out of experimental preview. Microsoft's public post says agents can now load instructions, reference documents, and scripts only when needed through a stable API, using progressive disclosure to keep context lean.
@DivyanshT91162 surfaced (5 likes, 1 reply, 357 views) NVIDIA's open-source skills catalog. The public repository says it is a mirrored catalog of official, NVIDIA-verified portable skills installable via the skills CLI, which turns "skills" from a community habit into a governable distribution format.
Discussion insight: The underlying shift was from always-on prompting to on-demand capability loading. Reuse, versioning, and packaging were the point, not prompt cleverness.
Comparison to prior day: July 8 emphasized registries and discovery. July 9 showed the same idea hardening into framework APIs and open repositories that people were actively combining.
1.4 Operator surfaces around agents kept expanding into products π‘¶
Several posts focused on the layers humans use to supervise, recover, secure, and extend agent work once it leaves a chat window. The result was a product conversation about workspaces, orchestration panels, security scanners, and action rails rather than about one more autonomous demo.
@circle released (108 likes, 16 replies, 8,814 views) open-source Agent Stack starter kits for adding wallets, USDC payments, and onchain actions across OpenAI Agents SDK, Anthropic's agent SDK, LangChain Deep Agents, Mastra, Vercel AI SDK, and Google ADK. The replies immediately shifted from announcement to operator concerns, especially who should actually absorb gas and transaction costs when agents start taking actions.
@gabegreenberg said (3 likes, 418 views) that true multi-agent orchestration is hard but possible, and the public ORC site now gives that claim a concrete shape: up to 20 specialized agents on one task, review gates, auditability, self-learning skills, and a claimed 8.6 percent lift on SWE Bench Pro.
@trySynara released (13 likes, 4 replies, 2,245 views, 12 bookmarks) Synara v0.4.1 with a dedicated workspace for non-coding agent work, inline PR diffs in the timeline, visible worktree setup, and a reliability pass across restore, reconnect, and transcript state. That makes it a good example of agent tooling shifting toward operator visibility instead of just more autonomy.
@tom_doerr shared (3 likes, 1,921 views, 5 bookmarks) ship-safe, a repo for scanning codebases for AI agent security risks. The public repository says the CLI uses 23 agents to scan for secrets, injections, AI or LLM vulnerabilities, and supply-chain issues, then shows diffs and verifies fixes before they land.
Discussion insight: The consistent move was to put visible control surfaces around agent action: diffs, dashboards, gates, restore points, and audit trails.
Comparison to prior day: July 8 highlighted infrastructure needs like payments and runtime isolation. July 9 pushed those concerns up into visible products that try to make coordination, recovery, and security operable day to day.
2. What Frustrates People¶
Cost control still depends on harness discipline, not just model choice¶
High severity. @ArtificialAnlys showed (674 likes, 22 replies, 34,448 views, 105 bookmarks) that GPT-5.6 Sol can get close to Claude Fable 5 at far lower cost, but @danshipper still found (649 likes, 42 replies, 108,379 views, 395 bookmarks) a large coding-quality gap on harder tasks. @databricks added (23 likes, 1,682 views) that token pricing is a poor proxy for real-world cost, and @RoundtableSpace framed (48 likes, 15 replies, 45,057 views) the pain operationally: elite models default to rewriting too much, so teams end up installing preflight gates just to stop waste. People are coping with subagent routing, pre-write checks, and harness tuning before they even consider fine-tuning. This is worth building for because the frustration appears in both benchmark posts and practitioner replies.
Teams still struggle to capture corrections and prove that a fix really worked¶
High severity. @free_ai_guides said (9 likes, 464 views, 12 bookmarks) most teams keep execution traces but lose the user's corrective edits, while @jackyk02 proposed (32 likes, 3 replies, 70,251 views) a heavier-weight verifier stack to get richer signals from agent behavior. @clairevo made (203 likes, 10 replies, 19,864 views, 268 bookmarks) the same point operationally by building verification directly into a Sentry bug-fix harness, and @ArchiveExplorer described (17 likes, 3 replies, 954 views, 14 bookmarks) a paper where broken harness components get rewritten and automatically reverted on regression. Builders are coping with external evaluators, memory taxonomies, and explicit pass-fail contracts. This is worth building for because trust fails when corrections disappear or when success cannot be independently verified.
Skill reuse is improving, but packaging is still fragmented¶
Medium severity. @MengTo had to pair (21 likes, 2 replies, 2,023 views, 35 bookmarks) two separate skill repositories to cover design engineering and orchestration, @dotnetfdn announced (4 likes, 385 views) a stable Agent Skills API for .NET, and @DivyanshT91162 pointed to (5 likes, 1 reply, 357 views) NVIDIA's separate verified-skill catalog. The good news is that packaging exists. The frustrating part is that expertise now lives across repos, framework APIs, and vendor catalogs with different install paths and governance rules. This is worth building for because the pattern is clearly moving toward reusable skills, but discovery and interoperability are still uneven.
Agents still stall when they need to touch the real world safely¶
High severity. @Freyabuilds complained (70 likes, 14 replies, 7,636 views) that agents stop feeling magical once they need to host a site, send an email, scrape a page, or take a payment, because the human still has to chase keys, subscriptions, and config. @circle responded from the builder side (108 likes, 16 replies, 8,814 views) with starter kits for wallets and USDC payments, but replies immediately asked who should actually pay gas fees. @shieldzcash offered (2 likes, 31 views) a keyless payment API, while @tom_doerr shared (3 likes, 1,921 views, 5 bookmarks) a security scanner specifically for AI agent risks. People are coping with starter kits, agent-readable dashboards, and scan-before-ship workflows. This is worth building for because autonomy now breaks on execution, spend, and safety boundaries more often than on reasoning alone.
3. What People Wish Existed¶
Cost-aware routing and preflight policy layers¶
This need showed up as a practical workflow gap, not a theoretical one. @danshipper described (649 likes, 42 replies, 108,379 views, 395 bookmarks) a world where GPT-5.6 Sol is good enough for many loops but not for the hardest coding tasks, @ArtificialAnlys quantified (674 likes, 22 replies, 34,448 views, 105 bookmarks) the cost differences across reasoning tiers, and @RoundtableSpace offered (48 likes, 15 replies, 45,057 views) a manual gatekeeping framework to reduce waste before generation starts. What people seem to want is a reusable layer that decides when to route up, when to route down, and what checks must pass before the model spends tokens. Opportunity rating: [+++] direct.
A correction memory and verifier layer that survives past one run¶
The strongest unmet need was durable learning from mistakes. @free_ai_guides said (9 likes, 464 views, 12 bookmarks) the user's fixes usually go uncaptured, @jackyk02 showed (32 likes, 3 replies, 70,251 views) that richer verifier signals can materially improve agent evaluation, and @ArchiveExplorer described (17 likes, 3 replies, 954 views, 14 bookmarks) a harness that rewrites only the failing contract and reverts regressions automatically. The missing product is not more memory in the abstract. It is a memory-and-verifier layer that stores fixes, scores behavior, and decides what should be changed next. Opportunity rating: [+++] direct.
Portable skill packaging that works across ecosystems¶
The skill trend now looks real enough that people want a common distribution pattern. @MengTo mixed (21 likes, 2 replies, 2,023 views, 35 bookmarks) two separate repos to cover different work types, @dotnetfdn announced (4 likes, 385 views) a stable .NET format for loading skills on demand, and @DivyanshT91162 pointed to (5 likes, 1 reply, 357 views) NVIDIA's verified catalog. The practical wish is obvious: package expertise once, discover it easily, and install it without re-authoring for every framework. Opportunity rating: [++] competitive.
Real-world action rails with clear spend ownership¶
The need here was half technical and half operational. @Freyabuilds spelled out (70 likes, 14 replies, 7,636 views) the boring tasks agents still hand back to humans, @circle opened (108 likes, 16 replies, 8,814 views) starter kits for wallets and USDC payments, and @shieldzcash published (2 likes, 31 views) a keyless payment API that returns pay links and agent-readable dashboards. Replies still asked the unresolved question: who pays for each action, and how visible is that spend? Opportunity rating: [++] direct.
Governed operator surfaces for multi-agent work¶
People also appear to want supervision tooling that sits above the agents themselves. @gabegreenberg previewed (3 likes, 418 views) ORC as a governed multi-agent coding platform, @trySynara shipped (13 likes, 4 replies, 2,245 views, 12 bookmarks) a more visible workspace for non-coding agent work, and @tom_doerr framed (3 likes, 1,921 views, 5 bookmarks) security scanning as a first-class step before shipping. This is less a wish for "more autonomous agents" than for better surfaces to see, review, approve, and recover what the agents did. Opportunity rating: [++] competitive.
4. Tools and Methods in Use¶
| Tool | Category | Sentiment | Strengths | Limitations |
|---|---|---|---|---|
| GPT-5.6 Sol + ChatGPT Codex | Model and desktop agent app | (+/-) | Fast; cheaper than Fable; strong writer; strong coding-agent showing inside Codex harness; good for whole-loop knowledge work | Trails Fable on hardest coding tasks; app split between Work and Codex still feels awkward to some users |
| Claude Fable 5 | Frontier model | (+/-) | Highest top-end coding quality in the day's comparisons; cleaner code; still leads some knowledge-work benchmarks | Expensive token burn; harder to use well; practitioners still pair it with cheaper subagents |
| ClaudeDevs SDK custom harness | Agent SDK | (+) | Lets builders define bug-triage, root-cause verification, and shipping workflows explicitly | Requires custom harness design and ongoing judgment outside the model |
| Databricks benchmark harness | Evaluation harness | (+) | Tests coding agents on real engineering tasks in a large codebase; exposes cost-performance tradeoffs that token pricing hides | Benchmark design is heavy; reveals that harness choice can invalidate simple price assumptions |
| LLM-as-a-Verifier | Evaluation framework | (+) | Fine-grained scoring; repeated evaluation; strong published benchmark results; useful for monitoring and scaling | Adds evaluation passes and complexity; still research-oriented rather than plug-and-play |
| Agent skills packages and repos | Skill packaging | (+) | Reusable instructions, docs, and scripts; on-demand loading keeps context lean; works across multiple agent styles | Packaging is fragmented across repos, framework APIs, and vendor catalogs |
| NVIDIA/skills | Vendor skill catalog | (+) | Public verified catalog; installable with the skills CLI; governance-forward packaging of NVIDIA capabilities | Narrowly scoped to NVIDIA software; separate catalog adds another discovery surface |
| Circle Agent Stack | Wallets and payments toolkit | (+/-) | Starter kits across major agent frameworks; adds wallets, USDC payments, and onchain actions quickly | Spend ownership and gas-fee UX remain unresolved in replies |
| Shieldz crypto payment API | Payments API | (+/-) | Keyless; non-custodial; returns pay links, embeds, and agent-readable status in one call | Low public adoption signal in this dataset; crypto-specific use case |
| Orc AI | Multi-agent orchestration platform | (+) | Coordinates specialized agents; exposes review gates, memory, and audit surfaces; claims benchmark lift | Still in preview; limited independent user validation in the day's tweets |
| Synara | Agent workspace | (+) | Dedicated non-coding workspace; inline diffs; clearer project actions; better reconnect and restore behavior | Focus is still reliability polish, suggesting operator surfaces remain immature |
| ship-safe | Security scanner | (+) | Scans for secrets, injections, AI or LLM risks, and supply-chain issues; shows diffs and verifies fixes | Low-engagement launch signal; unclear how broadly deployed it already is |
Overall, satisfaction clustered into two camps. Frontier models and harnesses drew strong enthusiasm when they reduced cost or increased control, but nearly every positive post also included a control caveat: routing, gates, verifiers, or review surfaces had to sit around the model to make it usable. The most common workaround was pairing tools rather than replacing them, such as using GPT-5.6 Sol under Fable, starting with harness engineering before fine-tuning, or layering verification on top of generation. Competitive dynamics are shifting from "best model" toward "best operating system around the model": skill packaging, orchestration, recovery, payments, and security are all now part of the method stack.
5. What People Are Building¶
| Project | Who built it | What it does | Problem it solves | Stack | Stage | Links |
|---|---|---|---|---|---|---|
| Sentry triage harness | @clairevo | Triage Sentry bugs, verify root cause, and ship fixes through a custom harness | Replaces micromanaged bug-fix chats with a defined workflow | ClaudeDevs SDK; Sentry | Alpha | tweet |
| Agent Skills for .NET | @dotnetfdn | Package instructions, docs, and scripts as on-demand skills in Microsoft Agent Framework | Reuse domain expertise without bloating every agent's context | .NET; Microsoft Agent Framework; progressive disclosure skill loading | Shipped | tweet, blog |
| NVIDIA/skills | @DivyanshT91162 | Public catalog of portable, verified skills for NVIDIA software | Gives builders reusable governed capabilities instead of hand-rolled prompts for every task | GitHub catalog; skills CLI; NVIDIA software skills | Shipped | tweet, repo |
| Circle Agent Stack starter kits | @circle | Add wallets, USDC payments, and onchain actions to agents across major frameworks | Removes repeated payment and action integration work | OpenAI Agents SDK; Claude Agent SDK; LangChain Deep Agents; Mastra; Vercel AI SDK; Google ADK; USDC | Shipped | tweet |
| Shieldz crypto payments | @shieldzcash | Return payment links, tip jars, embed code, and agent-readable status from a keyless API | Lets agents take payments without forcing the operator to set up accounts or keys first | HTTP API; ClawHub skill; Base; USDC; USDT | Shipped | tweet, docs, skill |
| Orc AI | @gabegreenberg | Governed multi-agent coding platform with coordinated workers, memory, and review gates | Coordinates long-horizon engineering work that strains single-agent flows | Orchestrator; MCP servers; memory mesh; model-flexible orchestration | Beta | tweet, site |
| Synara v0.4.1 | @trySynara | Workspace for non-coding agent work with inline diffs, visible worktrees, and stronger restore behavior | Improves visibility and reliability around agent operations | Workspace UI; PR diff timeline; project actions; worktree controls | Beta | tweet |
| ship-safe | @tom_doerr | AI security agent that scans codebases, proposes fixes, and verifies them | Catches agent-exposed security risks before they ship | CLI; 23 scanning agents; diff-and-verify remediation flow | Shipped | tweet, repo |
The strongest build pattern was not "new model, new app." It was "new control layer around existing models." Clairevo's Sentry harness, Orc's governed multi-agent panel, Synara's workspace release, and ship-safe's diff-and-verify scanner all fit that pattern from different angles.
Payments were the other repeated trigger. Circle and Shieldz both try to remove the custom glue between an agent decision and a real financial action, which lines up directly with the pain @Freyabuilds described (70 likes, 14 replies, 7,636 views) when agents hit hosting, email, scraping, and payment tasks in the wild.
A second repeated build pattern was turning expertise into reusable packages. Agent Skills for .NET, NVIDIA/skills, and the smaller open skill repos all suggest that teams increasingly want to ship capabilities as portable units rather than bury them inside one giant prompt or one proprietary agent surface.
6. New and Notable¶
Real-codebase benchmarking, not just toy tasks¶
What stood out was not another benchmark screenshot by itself, but the fact that @databricks benchmarked (23 likes, 1,682 views) coding agents on real engineering tasks inside a multi-million-line codebase and concluded that harness choice can change both cost and quality. That matters because it moves the conversation closer to how teams actually buy and operate agent systems.
Skills crossed into stable framework and vendor formats¶
@dotnetfdn announced (4 likes, 385 views) that Agent Skills for .NET is now stable, while @DivyanshT91162 surfaced (5 likes, 1 reply, 357 views) NVIDIA's public verified-skill catalog. The notable part is not just more skills; it is that major ecosystems are converging on packaging, discovery, and governance as first-class concerns.
Security and governance became visible product layers¶
@tom_doerr shared (3 likes, 1,921 views, 5 bookmarks) a security scanner aimed at AI agent risks, and @gabegreenberg previewed (3 likes, 418 views) a governed multi-agent platform with review gates and auditability. The notable signal is that supervision and security are being sold as core product surfaces, not as afterthoughts.
7. Where the Opportunities Are¶
[+++] Cost-aware harness control planes β The best evidence today came from three different directions: @danshipper comparing Sol against Fable in actual work, @ArtificialAnlys publishing cost-per-task deltas, and @databricks showing that harness choice changes the economics on real codebases. @RoundtableSpace adds a concrete preflight pattern. This is strong because the pain is widespread and the workaround patterns are already clear.
[+++] Verifier plus correction-memory layers β @free_ai_guides, @jackyk02, @clairevo, and @ArchiveExplorer all point to the same missing layer: capture what the user fixed, score trajectories externally, and rewrite only what failed. This is strong because it improves trust, learning, and control at the same time.
[++] Cross-framework skill packaging and discovery β @MengTo, @dotnetfdn, and @DivyanshT91162 show that reusable skills are real, but still fragmented across repos, frameworks, and vendor catalogs. This is moderate because the need is clear, yet distribution standards and discovery layers may become crowded quickly.
[++] Agent-native action and payment rails β @circle, @shieldzcash, and @Freyabuilds all identify the same break point between reasoning and execution. This is moderate because the demand is concrete, but spend ownership, compliance, and user trust are still open questions.
[+] Governance-first operator workspaces β @gabegreenberg, @trySynara, and @tom_doerr show a growing class of products built around review gates, diff visibility, restore behavior, and security scans. This is emerging because the surfaces are clearly needed, but the products are still early and public adoption signals are lighter.
8. Takeaways¶
- The buying question shifted from "best model" to "best harness economics." GPT-5.6 Sol's launch-day discussion kept circling back to cost-per-task, routing, and workflow fit rather than raw intelligence alone. (source)
- External verification is no longer optional in serious agent loops. The day's strongest self-improvement posts all depended on evaluators, root-cause checks, or contract-level pass-fail signals outside the model itself. (source)
- User corrections are becoming a first-class memory source. The clearest loop-design post today was about capturing what the user changed after the agent made a mistake, then storing it as reusable knowledge. (source)
- Skills are hardening into portable packaging formats. Open repositories, a stable .NET API, and NVIDIA's verified catalog all treated expertise as something agents should discover and load on demand. (source)
- The hardest autonomy gap is still execution in the real world. Payments, hosting, email, scraping, and secure shipping all surfaced as layers where humans still step back in, which explains why starter kits, payment APIs, and security scanners are getting built. (source)