Twitter AI Agent - 2026-08-23¶
1. What People Are Talking About¶
1.1 Skills, curricula, and reusable playbooks became the main packaging layer for agent expertise (🡕)¶
The strongest cluster treated agent know-how as something to version, compress, distribute, and teach, not something to rediscover in every prompt. High-signal posts converged on the same idea from different angles: AGENTS.md should be maintained like a model artifact, skill packs should be installable across runtimes, and curricula should leave learners with reusable prompts, SKILL.md files, agents, and MCP servers. Compared with August 22's focus on memory and harness portability, August 23 pushed one layer closer to operational packaging: how agent knowledge is maintained, shipped, and taught.
@kunchenguid wrote (237 likes, 15 replies, 9,029 views, 429 bookmarks) that project-level AGENTS.md files should be trained from session transcripts instead of edited from vibes. The linked blog turns that into a concrete loop: fixed token budget, two-session minimum evidence for new rules, no more than five edits per pass, and human review before backpass apply writes anything. That made the post more than style advice; it was a public recipe for converting session logs into repeatable agent-memory maintenance.
@I_AM_AYASHA collected (43 likes, 13 replies, 26 bookmarks) 13 Claude courses spanning Claude 101, Claude Code in Action, Agent Skills, and MCP. The infographic matters because it adds structure the tweet alone does not: durations, audience labels, and a clear split between foundation, developer, educator, and business tracks, showing that agent skills and MCP have already become standard course modules rather than niche extras.
@techNmak highlighted (27 likes, 3 replies, 1,262 views, 41 bookmarks) rohitg00's AI Engineering from Scratch curriculum, which the tweet says spans 503 lessons, 20 phases, roughly 320 hours, and reusable outputs including prompts, SKILL.md files, agents, and MCP servers. The distinctive angle was pedagogical rather than promotional: build backprop, tokenizers, attention, and an agent loop from scratch first, then move up to production libraries.
Discussion insight: The replies were less interested in whether skills are useful and more interested in maintenance discipline: how to keep playbooks coherent, how to avoid stale instructions, and how to teach abstractions without hiding the mechanics.
Comparison to prior day: August 22 treated skills and memory as infrastructure. August 23 treated them as managed content: trainable memory files, installable playbooks, and large public curricula.
1.2 Graphs, protocols, and closed-loop harnesses replaced single-window prompt craft as the main abstraction (🡕)¶
A second cluster argued that the important design moves now happen above the prompt. Instead of asking how to fit more into one context window, builders kept talking about graph topology, protocol surfaces, progressive loading, and evaluation loops that can promote or reject changes. Compared with August 22's emphasis on queues, workers, and retry plumbing, the August 23 discussion moved toward the abstractions that make those systems composable and tunable.
@hanakoxbt argued (68 likes, 5 replies, 5,288 views, 75 bookmarks) that context engineering and graph engineering solve different problems: one optimizes a single window, the other decides how many windows exist and what each one is allowed to see. The most useful part of the thread was the warning that path-scoped rules get summarized away while root rules survive, and that parallel agents sharing the same context often collapse into one opinion with three echoes.
@rauchg argued (166 likes, 20 replies, 8,672 views, 64 bookmarks) for open protocols as the extension surface for agent systems: MCP, skills, plugins, and Unix-style composition. The replies added real cost-model nuance instead of just agreement: unlike shell pipelines, model-mediated tool chains keep rereading intermediate output into context, so every extra hop can multiply token spend.
@HARNESSROUTER announced (104 likes, 7 replies, 9,466 views, 207 bookmarks) an Apache-licensed self-hosted router and open Unified Harness Protocol for Codex, Claude Code, Hermes, and DeepSeek Harness. The most valuable reply was not praise but a boundary test: one commenter said tools may carry across a handoff, but prior decisions do not, which exposes the next unsolved layer in cross-harness portability.
@trevin reported (146 likes, 17 replies, 13,029 views, 132 bookmarks) that Compound Engineering rewrote nearly every skill to load essentials first and pull detailed procedures only when needed, shrinking always-loaded instructions by about 70%. That is a concrete example of the day's abstraction shift: not “write a better prompt,” but decide what loads up front, what is deferred, and how much context each step deserves.
@shivam74689 built (8 likes, 3 replies) a closed-loop prompt lifecycle around failure analysis, controlled comparisons, approval, rollback, and monitoring. Even at low engagement, the image was one of the day's clearest artifacts because it showed the exact production loop surrounding an agentic system rather than just the model inside it.
Discussion insight: The common move was to shift optimization out of live chat. Builders kept externalizing state, making topologies explicit, and insisting that changes survive controlled evaluation before they graduate into the runtime.
Comparison to prior day: August 22 made queueing and review loops explicit. August 23 built on that by debating the higher-level shapes around them: graphs, protocol boundaries, progressive loading, and closed-loop promotion.
1.3 Trust, critique, and scope control stayed central as agents moved into real work (🡒)¶
The governance discussion stayed strong, but it became more concrete. Instead of broad warnings about dangerous actions, posts described time-bounded permissions, repo trust gates, reviewer/critic structures, and frontend pause/resume patterns for human approval. Compared with August 22's focus on confirmation gates and approval owners, August 23 added product and research mechanisms that make those controls operational.
@0xRiRoyal argued (121 likes, 87 replies) that agent permissions need an expiration date and proposed “permission half-life” as the metric that matters. The point was not least privilege in the abstract, but stale authority specifically: software keeps approvals long after humans forget why they were granted.
@witcheer listed (52 likes, 8 replies, 1,590 views, 20 bookmarks) Hermes Agent changes that directly answer trust and ops concerns: repo-scoped skills only load after hermes skills trust, zero-key search fails over across providers, long tasks no longer stop mid-run, and hermes update --plan now prints a receipt and verifies what changed.
@omarsar0 highlighted (15 likes, 9 replies, 2,277 views, 19 bookmarks) the Adversarial Review paper, where a main coding agent works with a reviewer and a critic instead of simply adding more reviewers. The attached paper page matters because it shows three agents beating a five-agent baseline on LiveCodeBench and recovering from a false-consensus failure mode on SWE-PRBench by making disagreement explicit.
@danteisshipping argued (1 like, 2 replies) that product agents still need a UI layer for editable drafts, page context, browser-side capabilities, and pause/resume approval flows, using CopilotKit and AG-UI as the example. That made human-in-the-loop control feel less like a policy box and more like a concrete product integration requirement.
Discussion insight: Replies kept asking for concrete evidence and control surfaces: unique failing evidence in review, repo trust before loading skills, explicit renewals for authority, and approval points that exist in the product rather than only in logs.
Comparison to prior day: August 22 framed approval and rollback as necessities. August 23 added more specific mechanisms: expiring permissions, trust-gated repo skills, critic agents, and frontend pause/resume controls.
2. What Frustrates People¶
Always-loaded context and stale instructions still tax every session¶
The clearest frustration was that agent systems keep paying for instructions long after those instructions stop helping. @kunchenguid wrote (237 likes, 15 replies, 9,029 views, 429 bookmarks) that project memory files tend to become empty, bloated, stale, or drifted, while his linked blog argues that anecdote-driven edits are what create the bloat. @trevin reported (146 likes, 17 replies, 13,029 views, 132 bookmarks) that Compound Engineering had to rewrite nearly every skill to cut always-loaded instructions by about 70%, and @hanakoxbt argued (68 likes, 5 replies, 5,288 views, 75 bookmarks) that path-scoped rules get summarized away while root rules survive. The coping patterns were consistent: progressive loading, smaller workflows for smaller jobs, and transcript-backed pruning instead of endless rule accretion. Severity: High. Worth building for: High.
More agents often multiply correlation instead of coverage¶
A second frustration was that adding more agents often adds ceremony faster than it adds evidence. @omarsar0 highlighted (15 likes, 9 replies, 2,277 views, 19 bookmarks) a paper where three agents with structured disagreement beat a five-agent baseline, while one reply said reviewer count should be treated as coverage for independent failure modes, not as a blanket quality multiplier. @hanakoxbt argued (68 likes, 5 replies, 5,288 views, 75 bookmarks) that shared context makes parallel agents converge on the same answer, so four auditors can become one opinion with three echoes. The workaround people kept reaching for was not raw fan-out but differentiated evidence: reviewer, critic, different context slices, and explicit disagreement. Severity: High. Worth building for: High.
Authority still goes stale faster than agent platforms revoke it¶
The trust complaint was not just “agents have too much power,” but “authority lingers after the reason for granting it is gone.” @0xRiRoyal argued (121 likes, 87 replies) for permission expiry and renewal, while @witcheer listed (52 likes, 8 replies, 1,590 views, 20 bookmarks) repo-scoped skill trust gates and update receipts as new Hermes safeguards. @danteisshipping argued (1 like, 2 replies) that product agents still need editable drafts and pause/resume approval inside the UI, and @suraj_sharma14 wrote (23 likes, 1 reply, 39 bookmarks) that running untrusted model output without a sandbox is “a breach waiting to happen.” The practical coping pattern was to add renewals, trust commands, approval gates, and isolated execution layers around the model rather than inside it. Severity: High. Worth building for: High.
3. What People Wish Existed¶
Skill maintenance that learns from transcripts instead of growing by anecdote¶
This was a practical need, and people described it with urgency because the alternative is paying for stale instructions forever. @kunchenguid wrote (237 likes, 15 replies, 9,029 views, 429 bookmarks) that project memory should be updated from transcript evidence in small, budgeted steps, while @trevin reported (146 likes, 17 replies, 13,029 views, 132 bookmarks) the amount of work it took to make skills load progressively instead of all at once. Mercury Skills and UX/UI Agent Skills show that distribution exists, but the replies under Mercury make clear that coherence and staleness remain open problems. Opportunity: direct.
Cross-harness and cross-product state that preserves decisions, not just tools¶
People want agents to move across runtimes and UI surfaces without losing the reasoning that already happened. @HARNESSROUTER announced (104 likes, 7 replies, 9,466 views, 207 bookmarks) one API for multiple harnesses, but the key reply said sessions still carry tools more cleanly than decisions. @danteisshipping argued (1 like, 2 replies) that real products also need editable drafts, frontend tools, and pause/resume approval in-place, not in a separate chat shell. This is a practical need with direct commercial value because it blocks real product integration today. Opportunity: direct.
Review and self-improvement loops that can prove a change helped¶
The strongest need was for systems that separate proposing a change from proving it improved anything. @shivam74689 built (8 likes, 3 replies) a prompt registry and comparison loop around a fixed 30-case suite, @rohanpaul_ai summarized (45 likes, 8 replies, 2,981 views, 30 bookmarks) AutoDesign's harness optimizer that keeps only changes that help without hurting held-out tasks, and @omarsar0 highlighted (15 likes, 9 replies, 2,277 views, 19 bookmarks) structured disagreement as a way to surface evidence instead of consensus theater. This is almost entirely a practical need, and today's evidence suggests partial solutions exist but are still fragmented between research prototypes and one-off internal systems. Opportunity: direct.
Production backend primitives for agent products¶
There was explicit demand for the boring infrastructure that makes agent products survivable. @suraj_sharma14 wrote (23 likes, 1 reply, 39 bookmarks) that builders should expect to ship an LLM gateway, token metering, streaming infrastructure, RAG ingestion, semantic cache, async job queue, execution sandbox, prompt/config versioning, eval pipelines, observability, webhook fan-out, context assembly, guardrails, and model routing. That list reads like a market map for missing infrastructure, and almost all of it is practical rather than aspirational. Opportunity: direct.
4. Tools and Methods in Use¶
| Tool | Category | Sentiment | Strengths | Limitations |
|---|---|---|---|---|
| Backpass | Memory / instruction upkeep | (+) | Distills transcripts into small, evidence-backed AGENTS.md updates with a budget and human review | Needs enough prior sessions to learn from and still depends on manual acceptance |
| HarnessRouter / UHP | Harness runtime / protocol | (+/-) | Self-hosted API across multiple harnesses, with sessions, files, streaming, and failure handling | A reply said cross-harness handoffs still preserve tools better than prior decisions |
| Compound Engineering | Skill / workflow layer | (+) | Progressive loading cuts wasted context and supports smaller workflows for smaller jobs | Reaching the smaller footprint took repeated rewrites, evals, and regression checks |
| Mercury Agent Skills | Skill registry | (+) | 132 curated playbooks, cross-agent install surface, browser and CLI entry points | Curated registries still face playbook conflict and staleness questions |
| UX/UI Agent Skills | Vertical skill pack | (+) | Design tokens, accessibility constraints, 138 design systems, framework adapters | Long constraint hierarchies still need careful ordering so the model does not ignore them |
| Hermes Agent | Coding agent runtime | (+) | Repo-scoped skills trust, zero-key search failover, update receipts, unlimited default turns | Requires trust onboarding and still accumulates operational work like worktree cleanup |
| CopilotKit / AG-UI | Frontend agent stack | (+) | Connects agent state to real UI, editable drafts, frontend tools, and human approval | More infrastructure than a simple chat app needs and still relies on backend orchestration |
| Claude Academy / course catalog | Courseware | (+) | Gives builders a structured path through Claude Code, Agent Skills, and MCP | Course completion does not solve production verification or repo-specific practice |
| AI Agents for Beginners | Courseware | (+) | 18 lessons on MAF, RAG, local/scalable deployment, and smoke tests | Educational surface rather than a deployable runtime |
| AutoDesign | Harness optimization method | (+) | Improves agents by changing prompts, tools, checks, or retries only when held-out results survive | Evidence today is benchmark-driven and depends on having a strong eval harness already |
| Adversarial Review | Code review method | (+/-) | Structured disagreement and a critic role reduce false consensus in code review | Research-stage and focused on repository review rather than general autonomy |
The satisfaction spectrum skewed positive for tools that moved state, evaluation, or trust outside the raw prompt and into explicit artifacts: registries, receipts, comparison suites, protocol surfaces, and UI approval layers. The common workaround pattern was to keep always-loaded instructions small, push narrow procedures into skills, and use either a critic or a fixed eval suite before promoting a change. The competitive dynamic is splitting between horizontal infrastructure that wants to sit underneath many agents (HarnessRouter, Mercury, CopilotKit) and vertical packs that want to own one dense workflow (UX/UI skills, offensive security, courseware for a particular stack).
@HeyAnjula mapped (6 likes, 2 replies) a seven-layer agent architecture that usefully summarized where the day's tools actually land: perception, reasoning, memory, planning, tool execution, guardrails, and observability.
5. What People Are Building¶
| Project | Who built it | What it does | Problem it solves | Stack | Stage | Links |
|---|---|---|---|---|---|---|
| Backpass | @kunchenguid | Distills local agent transcripts into proposed AGENTS.md updates with human review |
Keeps project memory from becoming bloated, stale, or anecdotal | JavaScript CLI, transcript distillation, quote extraction, evidence gates | Shipped | tweet blog repo |
| HarnessRouter Community Edition | @HARNESSROUTER | Routes Codex, Claude Code, Hermes, and other harnesses through one self-hosted API | Removes repeated harness engineering around sessions, files, streaming, and permissions | Python, UHP, provider integrations, self-hosting | Shipped | tweet repo |
| Mercury Agent Skills | Cosmicstack Labs | Publishes a registry of installable SKILL.md playbooks for coding agents | Lets teams reuse proven workflows instead of re-prompting every agent from scratch | JavaScript, Shell, Python, SKILL.md registry, web catalog | Shipped | tweet repo site |
| UX/UI Agent Skills | plugin87 | Packages design-system, accessibility, and component-engineering expertise into agent skills | Gives coding agents a repeatable design layer instead of ad hoc UI prompting | JavaScript, design tokens, WCAG guidance, framework adapters | Shipped | tweet repo |
| Cybermes | Zyrexnn | Offensive-security, bug-bounty, and red-teaming agent framework | Narrows agent autonomy into a specific security workflow with specialized reasoning | Python, Go, Hermes Agent, multi-model orchestration | Shipped | tweet repo |
| CopilotKit | CopilotKit | Frontend stack for agents and generative UI with AG-UI integration | Bridges agent state, approvals, and tool use into real product interfaces | TypeScript, React/Angular/Mobile/Slack, AG-UI | Shipped | tweet repo |
| AI Engineering from Scratch | rohitg00 | Open curriculum that ships reusable prompts, skills, agents, and MCP servers as course outputs | Teaches builders the primitives behind agent systems before the abstractions | Python, TypeScript, Rust, Julia, SKILL.md files, MCP servers | Shipped | tweet repo |
Backpass was the clearest example of builders treating agent memory as an engineering system instead of a prose document. The public blog describes deterministic evidence gates, a fixed token budget, and a human-reviewed apply step, which means the project solves for pruning and drift as much as for generation.
Mercury Agent Skills and UX/UI Agent Skills showed two different packaging directions. Mercury goes horizontal with a registry that spans many runtimes and categories, while UX/UI Agent Skills goes vertical with a dense design-specific bundle of tokens, accessibility rules, and system adapters.
HarnessRouter, CopilotKit, and Cybermes pointed to three other recurring build patterns: unify many harnesses behind one control surface, bind agents into product UI state and approval flows, or narrow the workflow into a high-value vertical like offensive security. AI Engineering from Scratch extended the same pattern into education by making course completion leave behind agent-usable artifacts instead of notes alone.
6. New and Notable¶
Harness optimization became a measurable alternative to buying a bigger model¶
@rohanpaul_ai summarized (45 likes, 8 replies, 2,981 views, 30 bookmarks) AutoDesign as a system that observes failures on real tasks and only keeps prompt, tool, validation, or retry changes that improve scores without hurting a held-out set. The attached poster makes the important point visible: the biggest gains were on weaker models, which turned “fix your harness before you upgrade your model” from a slogan into benchmarked evidence.
Public agent education moved beyond “what is an agent?” into deployment surfaces¶
@_vmlops reported (20 likes, 1 reply, 24 bookmarks) that Microsoft's AI Agents for Beginners course expanded to 18 lessons and now covers MAF, agentic RAG, context engineering, scalable deployment, computer-use agents, and local/on-device agents. That matters because it signals where mainstream teaching is going: not just chat patterns, but deployment surfaces, smoke tests, and production tradeoffs.
Vertical agent frameworks looked more credible when they narrowed the mission¶
@Dinosn highlighted (202 likes, 3 replies, 8,053 views, 242 bookmarks) Cybermes as an autonomous offensive-security, bug-bounty, and red-teaming framework powered by Hermes Agent, specialized reasoning skills, and multi-model orchestration. The public repo description makes the same point more concretely than the tweet: this is a Python/Go framework with releases, discussions, and an explicit security workflow, not just a generic “agent but for security” pitch.
7. Where the Opportunities Are¶
[+++] Skill lifecycle and context-budget tooling — Evidence came from section 1's transcript-trained AGENTS.md loop, Trevin's 70% smaller skill rewrites, Mercury's 132-playbook registry, and the course wave around Agent Skills and MCP. The recurring pain is not creating one more prompt; it is keeping reusable knowledge compact, current, and portable.
[++] Cross-harness and approval-aware control surfaces — HarnessRouter, CopilotKit, Hermes trust-gated repo skills, and the “permission half-life” discussion all point to the same gap: agents need a surface that carries state, preserves approvals, exposes receipts, and can pause safely inside a real product.
[++] Evidence-grounded evaluation and review loops — Closed-loop prompt promotion, AutoDesign's held-out checks, and Adversarial Review's critic-driven disagreement all suggest demand for systems that can propose changes, test them under controlled conditions, and reject consensus without evidence.
[+] Vertical expert packs for dense workflows — UX/UI Agent Skills and Cybermes show that narrow domains with heavy local rules are good candidates for packaged agent expertise. The opportunity is emerging because the pattern is visible, but the ecosystem still looks fragmented by repo, harness, and skill format.
8. Takeaways¶
- Reusable expertise became the product surface. Backpass, Mercury Skills, UX/UI Agent Skills, Claude's course catalog, and AI Engineering from Scratch all treated agent knowledge as something to package, prune, install, and teach rather than improvise per session. (source)
- The abstraction layer moved upward from prompt text to graphs, protocols, and promotion loops. Hanakoxbt's graph explainer, Rauch's protocol framing, HarnessRouter's UHP push, Trevin's progressive loading, and the closed-loop prompt-lifecycle diagram all pointed to the same shift. (source)
- Trust is increasingly being implemented as concrete controls, not generic safety language. Permission expiry,
hermes skills trust, update receipts, critic agents, and pause/resume approval flows were all presented as operational mechanisms, not principles. (source) - Harness quality and evaluation discipline still matter more than model bravado. AutoDesign's benchmark gains, Adversarial Review's structured disagreement, and Suraj Sharma's backend checklist all argued that durable progress comes from better surrounding systems, controlled experiments, and explicit infrastructure. (source)