Twitter AI Agent - 2026-07-20¶
1. What People Are Talking About¶
1.1 Loop engineering became the default vocabulary, with graph engineering as the next argument (🡕)¶
The clearest shift was from “how do I prompt better?” to “what harness, loop, and state structure makes a fixed model useful?” Several high-signal posts treated prompts as the smallest piece of the system and focused instead on scheduling, memory, verification, subagents, stop conditions, and cost controls.
@Granite0x said (144 likes, 4 replies, 14,352 views, 268 bookmarks) that Ryan Lopopolo’s newly open-sourced harness-engineering repo was the best public example of improving agents “without changing the model.” The repo itself defines harness engineering as shaping the environment around a chosen model so the worker can recover intent, operate the real system, respect authority, prove outcomes, and leave the next run better equipped.
@sairahul1 argued (64 likes, 13 replies, 11,737 views, 123 bookmarks) that loop engineering, not prompt engineering, is where autonomous systems are heading, listing scheduling, memory, planning, verification, worktrees, MCP, guardrails, observability, and cost tracking as the real work. A reply from @rahilpirani pushed the conversation one step further: flat memory is not enough, because a loop needs a graph linking attempts to outcomes if it is going to learn from prior failures.
@milesdeutscher translated (72 likes, 14 replies, 20,270 views, 123 bookmarks) the same idea into an operator recipe: define a goal once, let the agent try, self-check, fix, and stop when conditions are met. The strongest reply nuance came from @Johnnysuede, who said loops only replace prompting when the loop carries its own standards; otherwise it is “either a treadmill or a lecture.”
@VaibhavSisinty said (65 likes, 14 replies, 4,119 views) the conversation was already moving from loops to graph engineering, using a three-agent pattern where one agent executes, one reviews, and one checks output against the user’s goal. @dosco added (54 likes, 1 reply, 1,996 views, 58 bookmarks) a more technical framing: DSPy, RLMs, PEEK, and GEPA matter because they make prompt space searchable, evaluable, and composable instead of relying on bespoke sub-prompts that do not generalize.
Discussion insight: The consensus was not “prompts are dead”; it was that prompts alone do not explain reliability anymore. The main disagreement was whether graph engineering is a genuinely new layer or just a clearer name for explicit state, decomposition, and verification.
Comparison to prior day: July 19 already elevated harnesses and loops over raw prompting; July 20 made loop engineering the mass-market label and moved the frontier argument toward graph structure, relationship-aware memory, and multi-agent coordination.
1.2 Agent know-how was being packaged into public guides, playbooks, and curricula (🡕)¶
A second strong theme was codification. Instead of isolated tips, the feed was full of public PDFs, courses, and series that try to turn agent-building into a teachable discipline for enterprises and coding teams.
@beamnxw summarized (66 likes, 21 replies, 2,725 views, 63 bookmarks) Anthropic’s 23-page “Building AI Agents for the Enterprise” guide as a distinction between point-solution adoption and organization-level transformation. The linked PDF says successful rollouts rethink employees, processes, and products together, and its contents match the tweet’s emphasis on upskilling, process acceleration, product transformation, governance, and compounding advantage.
@Mnilax highlighted (37 likes, 6 replies, 3,220 views, 66 bookmarks) OpenAI’s 34-page practical guide as a code-backed field guide covering models, tools, instructions, orchestration patterns, guardrails, and human handoff. The PDF itself defines agents as systems that manage workflow execution, use tools dynamically, and halt or return control on failure; the strongest reply from @bojan_ai said the gap is not architecture diagrams but unpublished postmortems on silent tool failures, context poisoning, wrong-task completion, and cost blowouts.
@pauliusztin_ announced (49 likes, 6 replies, 1,198 views, 33 bookmarks) an open-source series, “Building a Coding Agent From Scratch,” built around Modal, Kitaru, Opik, and Pydantic AI. The pitch was explicit that the loop is only one component, and that durable execution, permissions, sandboxes, skills, subagents, evals, and observability are what make coding agents production-grade.
@tonysimons_ released (23 likes, 2 replies, 1,255 views, 31 bookmarks) a twelve-part Hermes Agent masterclass covering memory, skills, tools, cron, gateways, subagents, browser/computer use, profiles, and system limits. That is the same codification pattern in a different package: people are shipping operating manuals, not just demos.
Discussion insight: The guides are getting more concrete, but replies repeatedly said the missing layer is operational: failure taxonomies, audit logs, cost measurement, and narrower rollout plans for smaller teams.
Comparison to prior day: July 19 centered repositories, papers, and implementation patterns; July 20 turned that same material into formal guides, public curricula, and enterprise documentation.
1.3 Memory and skills moved from theory into product surface area (🡕)¶
The feed did not treat memory as an abstract “RAG problem.” It treated memory, skills, and reusable context as product features that can be scoped, installed, searched, and carried across sessions and interfaces.
@lydiahallie showed (56 likes, 5 replies, 5,628 views, 46 bookmarks) that subagents can now get persistent memory through a dedicated memory field. In replies, she specified three scopes: user-wide learnings, project memory that teammates’ agents can share, and local repo memory that stays out of git; she also clarified that the field alone cannot merge user and project memory, which immediately surfaced a real limitation.
@gippp69 showcased (48 likes, 19 replies, 741 views, 28 bookmarks) Claudian, a 10,900-plus-star Obsidian plugin that embeds Claude Code, Codex, Opencode, and Pi inside a vault. The repo says the vault becomes the agent’s working directory, with file read/write, search, bash, multi-step workflows, slash skills, and MCP support, which makes stored notes and prior project context directly actionable.
@DataChaz described (19 likes, 7 replies, 1,881 views, 16 bookmarks) the ADHD skill for Claude Code as an architectural fix for premature convergence: parallel isolated branches diverge under different frames, then a separate critic clusters and prunes them. The repo backs that up with a two-phase design and public evals showing the biggest gain in trap detection, which is exactly the failure mode the replies discussed.
@tom_doerr reported (5 likes, 1,877 views, 9 bookmarks) that MemSearch now distills repeated workflows into reusable, installable agent skills for Claude Code and Codex. Its docs position that as a third memory layer: not just conversation recall, but procedural memory that turns repeated work into portable behaviors across Claude Code, Codex CLI, OpenClaw, and OpenCode.
Discussion insight: The highest-signal memory posts were specific about failure modes: subagents forgetting across runs, early anchoring in reasoning, and the need to turn repeated work into explicit reusable assets rather than hoping retrieval reconstructs the right context every time.
Comparison to prior day: July 19 emphasized context scoring, wiki memory, and local recall; July 20 showed memory and skill systems landing as installable plugins, scoped settings, and workflow distillation features.
1.4 Trusted delegation broadened from sandboxing to identity, action control, and payments (🡕)¶
The trust conversation widened beyond “how do I sandbox a coding agent?” into “how do I know an agent deserves authority, how do I inspect every action, and how does it pay for work?” The strongest posts were still partly aspirational, but they were concrete about mechanisms.
@karlmehta quoted (22 likes, 5 replies, 5,247 views) Cisco President Jeetu Patel saying zero trust for agents has to become action control, not just access control, because a wrong agent action can cause irreversible damage. That thread is notable for specifying the required control plane: inspect each action and intercept what is going wrong before it commits.
@ThuyTrang108 argued (63 likes, 55 replies, 721 views) for “verifiable history” as the basis of trust, with execution trails that connect permissions, conditions, and prior decisions over time. The most useful reply came from @zench4n, who said auditability without hard scope limits is “just a nice diary,” and @nykdotdev added that silent retries can corrupt the very history meant to prove trustworthiness.
@BuildOnCircle announced (67 likes, 15 replies, 3,242 views) that Circle Skills are now available in Remix for USDC, swaps, bridging, agent wallets, wallet architecture, and crosschain balances. In the same vein, @xrp_ana explained (37 likes, 1,316 views, 18 bookmarks) x402 as a machine-native payment flow where a server returns HTTP 402, an agent pays in stablecoins, retries automatically, and receives the service.
@SwarmBase noted (141 likes, 38 replies, 10,515 views) that BNB Chain already hosts more than 200,000 registered agents settling in stablecoins for compute payments, API billing, and cross-agent settlement, while the U.S. compliance rulebook is still unfinished. That is still promotional territory, but it is one of the few posts that tied agent payments to regulatory timing, operational uncertainty, and a public protocol stack.
Discussion insight: Many replies in this cluster were generic cheerleading, but the strongest ones converged on three missing pieces: hard permissions, liability when an agent causes loss, and action-by-action interception rather than after-the-fact logging.
Comparison to prior day: July 19 framed trust mainly as execution boundaries, approvals, and isolation for coding agents; July 20 extended the same concern into identity, verifiable history, wallet tooling, and machine-native payments.
2. What Frustrates People¶
Verification that can be gamed, bypassed, or never defined¶
The most acute frustration is not capability but proving that an agent actually did the work it claims. @Mnilax shared (37 likes, 6 replies, 3,220 views, 66 bookmarks) OpenAI’s guide, but the most informative reply said the real failures are silent tool errors, context poisoning, wrong-task completion, and cost blowouts rather than the happy-path architecture. @DamiDefi pushed (109 likes, 5 replies, 7,848 views) the loop thesis, but a reply from @Math_MntnrHZ said the verification step is the hard part: without it, a loop “just runs in circles.” @neheart made (12 likes, 2 replies, 138 views, 10 bookmarks) the same point operationally, arguing that models learn to game checks unless the referee is external and untouchable. Severity: High. People are coping with stop hooks, test gates, permissions, and independent reviewers, but the market signal is for verification layers that agents cannot edit around.
Memory that either disappears or rots¶
People want agents to remember, but they do not want brittle recall. @lydiahallie showed (56 likes, 5 replies, 5,628 views, 46 bookmarks) that subagents forget between runs unless they get explicit persistent memory, and a reply immediately asked for combined user and project memory, which the current field does not support alone. @0xwhrrari promoted (24 likes, 7 replies, 435 views) an Andrew Ng course on agentic knowledge graphs, but the most useful reply asked whether it covers graph maintenance, because stale edges are where memory becomes wrong. @DataChaz framed (19 likes, 7 replies, 1,881 views, 16 bookmarks) the adjacent issue as premature convergence: once an agent picks a bad first path, it keeps repairing the same mistake. Severity: High. Builders are responding with scoped memory, graph structures, and divergence-before-convergence skills, which makes this a direct product need rather than a research-only problem.
Enterprise and brownfield rollouts still assume cleaner systems than most teams have¶
The guides are popular, but operators kept pointing out that real teams start from messy repos, partial documentation, and weak data hygiene. In a reply to Anthropic’s enterprise guide, @niek_olthof said the gap he keeps hitting is that enterprise patterns assume infrastructure and data quality many 10-person companies do not have, and that the version that ships is “3 of these sections, not 7.” @mardehaym said (21 likes, 8 replies, 3,168 views) the most expensive week in an AI project is week one, because teams build the wrong thing; his workaround was a “Step 0” knowledge graph of modules, dependencies, data flows, and domain terms before generating code. Severity: Medium to High. This is worth building for because both the enterprise guide discussion and brownfield rebuild advice point to the same missing layer: repo cartography and rollout scaffolding for imperfect environments.
Cost and context blowups remain operationally painful¶
Cost anxiety showed up both as fear and as hard-won savings. A reply to @milesdeutscher mentioned avoiding APIs because of “horror stories” about unknown costs. @charles_maddock reported (37 likes, 10 replies, 2,453 views) that Strawberry cut credit use by 70% by patching prompt-cache misses, switching to GPT-5.6 Terra, and limiting oversized tool results so agents fetch context surgically instead of hauling entire sheets and memory trees into one prompt. Severity: Medium. People are coping with dashboards, cache-hit measurement, better model routing, and aggressive context pruning; that is a strong signal that “cost observability for harnesses” is still underbuilt.
3. What People Wish Existed¶
A real action-control plane for trusted delegation¶
The strongest practical ask is not more autonomy but safer autonomy. @karlmehta quoted (22 likes, 5 replies, 5,247 views) Cisco’s call for “action control” that can inspect every step and intercept wrong actions before they commit. @ThuyTrang108 wanted (63 likes, 55 replies, 721 views) verifiable execution history, but the best reply said logging is insufficient without hard scope limits. This is an urgent practical need with partial answers in audit trails, wallet permissions, and local brakes such as agent-security. Opportunity: direct.
Memory that preserves relationships, not just files, and spans the right scopes¶
People are explicitly asking for memory that lasts, stays inspectable, and connects related decisions over time. @lydiahallie showed (56 likes, 5 replies, 5,628 views, 46 bookmarks) scoped persistent memory, and a reply immediately asked for mixed user-plus-project memory. @0xwhrrari surfaced (24 likes, 7 replies, 435 views) interest in agentic knowledge graphs, while replies warned that stale edges and weak maintenance can quietly make memory wrong. Practical need, already competitive: MemSearch, Claudian, and knowledge-graph approaches all attack different pieces of it. Opportunity: competitive.
A brownfield starter kit for small teams, not just frontier-lab playbooks¶
The enterprise material landed, but so did pushback that smaller teams need a narrower, cheaper version. The clearest evidence is the reply to Anthropic’s guide that said small companies ship “3 sections, not 7,” plus @mardehaym arguing (21 likes, 8 replies, 3,168 views) for a repo-mapping “Step 0” before any code generation. This is a practical need: teams want agent rollouts that start with architecture discovery, invariants, and cost/permission baselines rather than assume mature data hygiene. Opportunity: direct.
4. Tools and Methods in Use¶
| Tool | Category | Sentiment | Strengths | Limitations |
|---|---|---|---|---|
| Harness Engineering | Method / repository | (+) | Makes intent, requirements, authority, proof, and reusable learning explicit around a fixed model | Requires heavy local curation and org-specific process data |
| Loop engineering | Method | (+/-) | Gives agents self-correction, stop conditions, scheduling, and verification loops | Verification standards are still underspecified; cost can spiral without guardrails |
| Deep Agents | Framework / harness | (+) | Bundles subagents, filesystem, shell, persistent memory, context management, and LangGraph/LangSmith production hooks | Security model explicitly says boundaries belong in tools and sandboxes, not the LLM itself |
| Persistent subagent memory | Product feature | (+) | Clear user/project/local scopes for cross-session recall | Does not inherit all memory automatically; one field alone cannot combine scopes |
| Claudian | Obsidian plugin / agent shell | (+) | Turns a vault into a working directory with edits, search, bash, skills, and MCP | Desktop-only and dependent on local CLI/provider setup |
| ADHD | Agent skill | (+) | Isolated divergent branches plus critic pass help with fuzzy debugging, naming, and API design | Best on open-ended design work; adds extra calls and latency |
| MemSearch | Memory layer / plugin | (+) | Cross-platform semantic memory and skill distillation from repeated workflows | Requires plugin/hook installation and disciplined memory maintenance |
| agent-security | Security tooling | (+) | Scans inbound code, outbound repos, fetched content, and destructive gh operations with explicit limits |
Deliberately only catches known patterns; cannot prove safety or follow all cross-file flows |
| Circle Skills in Remix | Wallet / onchain dev tooling | (+/-) | Gives developers wallet, USDC, bridging, and crosschain balance flows inside Remix | Narrowly useful outside onchain work; discussion quality was mixed |
| Harness cost controls (Strawberry) | Operations method | (+) | Cache-hit monitoring, better model routing, and surgical context fetching materially reduced spend | Depends on telemetry and continuous tuning; provider-side capacity issues still leak through |
The satisfaction spectrum was positive for anything that makes state, tools, or evaluation more explicit. People consistently praised harnesses, scoped memory, skills, and reusable shells; the friction came when those systems touched cost, trust, or long-lived state. Migration is away from hand-written prompt iteration and toward reusable operating layers: harness docs, memory plugins, skill bundles, graph runtimes, and independent gates. Skill bundles also surfaced repeatedly through Compound Engineering, ECC, and Matt Pocock’s skills, which suggests discovery and curation are becoming part of the tooling market.
5. What People Are Building¶
| Project | Who built it | What it does | Problem it solves | Stack | Stage | Links |
|---|---|---|---|---|---|---|
| Harness Engineering | Ryan Lopopolo | A repository of arguments, playbooks, and agent context for shaping the environment around a fixed worker | Makes local requirements, authority, and proof recoverable instead of rediscovered every run | Markdown docs, AGENTS.md, playbooks, context/tool patterns |
Shipped | repo |
| Claudian | YishenTu | Embeds Claude Code, Codex, Opencode, and Pi inside an Obsidian vault | Turns notes and prior project context into an active workspace instead of passive storage | Obsidian plugin, TypeScript, CLI providers, MCP | Shipped | repo, tweet |
| Social Arena | @olam_labs | A platform where humans play social games against AI agents, feeding public behavior benchmarks such as the Deception Index | Standard benchmarks miss long-horizon social behavior, negotiation, and deception | Multi-agent game environment, sandboxed model seats, transcript grading, human-curated rubric | Shipped | site, benchmarks, tweet |
| ADHD | Udit Akhouri | A skill that forces parallel divergent ideation before a separate critic pass | Reduces premature convergence in debugging, naming, API design, and other fuzzy engineering tasks | npm skill, isolated parallel calls, critic model, public evals | Shipped | repo, tweet |
| MemSearch | Zilliz | Cross-platform semantic memory for coding agents, now with skill distillation from repeated workflows | Agents keep forgetting past work and re-solving the same tasks | Python, Markdown memory, hybrid search, plugins for Claude Code/OpenClaw/OpenCode/Codex | Shipped | repo, docs, tweet |
| agent-security | @nykdotdev | Deterministic safety gates for inbound code, fetched content, outbound repos, and destructive GitHub operations | Agents can ingest poisoned content, leak private context, or run dangerous repo actions without noticing the trust boundary | Bash, Python, Git, local guards, offline fixture suites | Alpha | repo, tweet |
| Hermes Agent v0.19 | @IBuzovskyi | A major release focused on speed, smart approvals, vault-backed secrets, live subagent transcripts, and durable delegation | Multi-agent operations need faster startups, safer approvals, and better observability | CLI, gateway, TUI, desktop, cron, secret vault integrations | Shipped | tweet |
| Circle Skills in Remix | @BuildOnCircle | Adds wallet, USDC, swaps, bridging, and crosschain balance workflows to Remix | Developers need agent wallets and payment primitives without leaving familiar tooling | Remix, Circle Skills, Gateway, Circle CLI, Arc Testnet | Shipped | tweet |
The strongest repeated build pattern was “infrastructure around the agent,” not a brand-new agent persona. Harness Engineering, MemSearch, ADHD, and agent-security all try to reduce recurring failure modes by changing context, memory, ideation structure, or safety gates around the model rather than replacing the model itself.
Claudian and Hermes show the same pattern at the product-shell level. @gippp69 framed (48 likes, 19 replies, 741 views, 28 bookmarks) Claudian as turning an Obsidian vault into a live second brain, while @IBuzovskyi framed (21 likes, 2 replies, 2,092 views, 14 bookmarks) Hermes v0.19 as a production operator release: 80% faster first token, smart approvals by default, vault-backed secrets, and live transcript files for subagents.
The most novel evaluation build was Social Arena. @olam_labs said (62 likes, 23 replies, 2,381 views) its Deception Index is based on roughly 55,000 poker hands with humans and agents sharing the same environment, and the public benchmark page reports 55,130 hands measured on July 16. That stands out because it evaluates social behavior in a live multi-agent environment instead of a closed benchmark suite.
A smaller but concrete commercialization signal came from @pilvand posting (75 likes, 10 replies, 338,836 views, 37 bookmarks) that the first independent agent on indie.money had gone live, with “leadhunter” finding buyers on Reddit and only $0.54 in run fees so far. The reply that questioned whether Reddit scraping is allowed is useful context: early agent marketplaces are shipping, but trust and data-source constraints are still unsettled.
6. New and Notable¶
Social benchmarks that measure behavior, not just task completion¶
@olam_labs released (62 likes, 23 replies, 2,381 views) Social Arena and its first public benchmark, the Deception Index. The notable part is methodological: human and AI seats share the same game surface, results become permanent replayable records, and the public benchmark page reports deception, bluff rate, and aggression metrics over 55,130 poker hands. That is a more concrete attempt to evaluate long-horizon social behavior than most agent discourse offers.
“Skills from memory” became a real product primitive¶
@tom_doerr reported (5 likes, 1,877 views, 9 bookmarks) that MemSearch can now distill repeated workflows into installable skills. The public docs describe this as a procedural memory layer on top of semantic recall, which is notable because it converts past behavior into a reusable artifact instead of merely retrieving history.
Zero trust for agents was reframed as action control¶
@karlmehta quoted (22 likes, 5 replies, 5,247 views) Cisco’s argument that trusted delegation requires inspecting and intercepting actions, not just granting or denying access. The same theme appeared from the bottom up in @nykdotdev, who open-sourced (11 likes, 1 reply, 287 views, 8 bookmarks) agent-security as a preflight layer for repo publishing, inbound code vetting, content scanning, and destructive gh commands. The notable shift is that “trust” is being translated into concrete gates and control points.
7. Where the Opportunities Are¶
[+++] Verification and action-control infrastructure — Multiple threads converged on the same gap: loops need standards, enterprise guides omit failure taxonomies, trust requires action-by-action interception, and local brakes like agent-security are still honest tripwires rather than full control planes. Evidence spans @Mnilax, @DamiDefi, @karlmehta, and @nykdotdev. This is the strongest opportunity because the pain is both technical and governance-related.
[+++] Relationship-aware memory that survives sessions without drifting — The day’s memory posts were unusually concrete: persistent subagent scopes, Obsidian-as-workspace, semantic recall across harnesses, skills distilled from repeated workflows, and repeated warnings about stale edges or premature convergence. Evidence spans @lydiahallie, @gippp69, @tom_doerr, and @DataChaz. This is strong because both product builders and reply threads were precise about the failure modes.
[++] Brownfield onboarding and cost observability for agent rollouts — Teams want a “Step 0” that maps architecture, invariants, and data flows before code generation, plus dashboards that show where cache misses and context bloat are wasting spend. Evidence comes from the Anthropic guide discussion, @mardehaym, and @charles_maddock. This looks moderate rather than dominant, but it is one of the clearest near-term enterprise needs.
[+] Agent wallet, identity, and payment rails — The concrete pieces are appearing: Circle Skills in Remix, x402 payment flow, Robinhood’s quoted agentic account announcement, and threads about identity, permissions, and accountable track records. Evidence spans @BuildOnCircle, @xrp_ana, @ThuyTrang108, and @SwarmBase. It is still emerging because much of the feed here was promotional, but the underlying integration surface is real.
8. Takeaways¶
- The conversation moved another step away from prompt craft and toward operating systems for agents. Harnesses, loops, graphs, verification, and state management carried more weight than model-choice talk. (source)
- Public agent education matured fast on this date. Anthropic and OpenAI both had widely shared guides, while independent builders turned the same ideas into coding-agent curricula and masterclasses. (source)
- Memory is becoming a first-class product surface, not a hidden backend detail. Scoped persistent memory, vault-native agent shells, semantic recall, and “skills from memory” all point to the same direction. (source)
- Trust discourse is getting more concrete. The strongest posts were no longer generic pleas for safety; they specified action control, scope limits, verifiable history, wallet permissions, and preflight gates. (source)
- Builders are mostly shipping wrapper infrastructure around agents rather than wholly new agents. The most credible launches were harness repos, memory layers, security gates, benchmark environments, and shells like Claudian and Hermes. (source)
- Cost pressure is forcing better harness design. Strawberry’s reported 70% credit reduction came from cache-hit monitoring, cheaper routing, and aggressive context trimming, reinforcing the claim that many agent-cost problems are context-engineering problems. (source)