yarnnnNotes on building autonomous agent systems: task design, context accumulation, and what it means to supervise instead of execute.
Hermes is the leading edge of an open-source agent wave that will produce many more harnesses in the next 18 months. They'll converge on substrate philosophy. They'll diverge on autonomy. The ones that ship a structurally separate judgment seat will own the operations market.
Hermes Agent's GEPA (Genetic-Pareto Prompt Evolution) is real engineering. The ETH Zurich reproduction shows 33-38% SWE-bench lift. The technique works. What it optimizes for is benchmarks, not the operator's specific outcomes — and that gap is the structural ceiling on self-optimization in agent systems.
Skills (the agentskills.io standard used by Claude Code, Hermes, and the wider open-source agent ecosystem) are composable single-purpose procedural units. Programs are a higher-order structure: a manifest, a reference workspace, a composition manifest, capability specs. The difference is what makes installable applications possible in an agent OS.
Two valid agent product shapes have crystallized. The personal automation daemon (Hermes, Claude Code in default shape) runs on your machine and gets better at procedures. The operations cockpit (YARNNN) runs an operation under operator-authored mandate and gates consequential action through a judgment seat. Different buyer, different shape.
Skills written from agent self-evaluation are skills written from internal scores. Calibration requires comparing the agent's predictions to outcomes the world actually produced. Without an outcome reconciliation loop, self-improvement becomes self-reinforcement of patterns the agent thinks worked.
An agent harness built around one persona can bolt on more skills, more tools, more sandbox backends. It can't bolt on an independent judgment seat without inverting its own loop. The Reviewer split is topological, not decorative.
Hermes Agent overtook OpenClaw on May 10 to become the #1 open-source agent on OpenRouter by daily token volume. The number is real. What it signals — and what it doesn't — is what to actually pay attention to.
Both treat the filesystem as the agent's mind. Both ship persona-first identity. Both make cron a first-class citizen. The architectural divergence is not in the substrate — it's in how each splits the agent that executes from the agent that judges.
Showing recurring AI work in a calendar widget is a category error. A calendar is for time-blocked appointments. Recurring AI work is cadence — a different shape that needs a different surface.
Most AI products show 'chat plus history.' That's not a cockpit — it's a transcript viewer. A real cockpit for autonomous AI shows the four faces of the operation: mandate, money truth, performance, tracking.
RAG was the right answer for question-answering over a knowledge base. It's the wrong answer for giving a persistent agent navigable memory. Compact index plus on-demand read is cheaper, more accurate, and structure-preserving.
The dominant pattern for AI memory is 'inject everything into every prompt.' It's expensive and unnecessary. Filesystem-as-memory — compact index plus on-demand reads — cuts token costs dramatically and produces a cleaner reasoning model.
Trading is the stress test for autonomous AI. The platforms that ship AI 'trading agents' today mostly produce signals you click. The architecture required to actually execute on your behalf is a different beast — and it generalizes far past trading.
The debate about open vs. closed agent harnesses asks who stores your data. The real question is whether your agents accumulate intelligence at all. Memory without accumulated context is just an empty filing cabinet you happen to own.
An autonomous AI is only as good as its ability to learn from outcomes. The outcome loop — proposed action, verdict, execution, real-world result, calibration — is the closed circuit that makes AI judgment improve over time.
Anthropic just shipped Managed Agents — a hosted agent harness that commoditizes the loop every agent startup built by hand. Here's why that's the best thing that could happen to you.
I graded every competitive claim we make against OpenClaw and Claude Code. Some are rock-solid. Some are softer than our docs make them sound. A couple are actively fragile. Here's the full breakdown.
Performance for autonomous AI operations should live in the substrate as a file every actor reads, not in a dashboard the operator stares at. The architectural choice changes what AI can learn from outcomes.
Linear, PostHog, and Attio all replaced their dashboards with chat bars in the same month. That's step two of a four-step transition. The industry is converging on a trajectory — dashboard to chat to generative UI to autonomous agents — and most companies are building for step two while the architecture for step four already exists.
Andrej Karpathy published a workflow for LLM-maintained knowledge bases — markdown files, auto-maintained indexes, outputs that feed back into the wiki. Every primitive he described maps to something I've already shipped. The validation is nice. The gap he identified is more interesting.
Sequoia's opportunity map is 2D. The market is 3D. The missing axis — transactional versus recurring — determines whether you need a transaction engine or an accumulation engine. YARNNN is building for the dimension they didn't map.
Three of the most respected judgment characters of the 20th century — a quant, an investor, and an engineer — turn out to be the right archetypes for the AI reviewer seat. The reason is structural, not romantic.
RAG answers questions. Accumulation builds understanding. For AI agents that need to produce recurring, autonomous output — not just respond to queries — the LLM-maintained knowledge base is a better architecture. Karpathy's workflow signals the shift.
Jack Dorsey wants to replace middle management with AI coordination. But the deeper question isn't who coordinates the humans — it's what happens when AI agents are the primary workers and supervision becomes the actual job.
When AI handles the cognitive labor that defined careers, human motivation splits in two. Some people will amplify their ambition with AI tools. Others will pursue meaning outside of economic production entirely. Both paths are valid — and both are new.
The playbook — degree, résumé, entry-level job, career ladder — was already cracking before AI. Now it's accelerating. The question isn't whether the old economy is coming back. It's what replaces it.
Every generation redefines work. Ours won't be different — except this time, the redefinition is forced by AI agents that can do the recurring cognitive labor humans used to sell as employment.
The AI agent industry is splitting into two structurally distinct categories. One builds tools — session-scoped, interactive, stateless. The other builds employees — persistent, autonomous, accumulating. The distinction isn't branding. It's architecture.
The AI industry is in a constant model arms race. The operators I talk to don't actually need a smarter model — they need a structural reviewer that gates consequential actions. The bottleneck isn't intelligence. It's accountable judgment.
LLMs are monolithic today — one model tries to do everything. But the jagged edges are showing. The domains nobody benchmarks are exactly where models fail hardest, and that's where speciation begins.
Every autonomous AI system needs a judgment seat. Most products fill it with a model identity ('GPT-4 reviewing'). The seat works better when the operator names it after the judgment character they want — Simons, Buffett, Deming. Persona is the load-bearing piece.
Claude can now control your computer — opening apps, navigating browsers, filling spreadsheets. It's a genuine breakthrough in the interface layer. But the hard part of knowledge work was never the clicking. It was always the knowing.
A task is a unit of work with a definition and a status. An operation is a continuous activity with a mandate and a trajectory. The distinction sounds semantic. It's actually the architectural fork in agent product design.
Everyone's arguing about where agents should run — local vs cloud. The real question isn't where. It's what happens after they're running.
Figma went from $20B acquisition target to existential crisis in 18 months. SaaS has no physical moat — no factories, no supply chains, nothing between the incumbent and the replacement except switching costs that AI is evaporating. But the disruption gradient isn't uniform across industries.
Google launched an AI-native design tool. Figma dropped 8%. The lesson isn't about design — it's about what happens to any platform that doesn't open itself to agents. Incumbents that can't be seen, read, and operated by AI will be bypassed by alternatives that can.
Wall Street is tracking AI eating SaaS budgets. But software-to-software reallocation is the surface story. The real disruption is AI agents replacing the labor that produces recurring knowledge work — and that's an HR/OpEx budget, not an IT budget.
yarnnn doesn't compete for IT budget against Salesforce or Notion. It competes for the work output that currently requires salaried employees. That's a fundamentally different market with fundamentally different economics.
The next architectural shape for AI agents isn't 'task management' or 'workflow automation.' It's mandate-driven operations: standing intent authored by the operator, autonomous execution governed by it, and a substrate that holds both.
Alfred Lin's 'Size of the Prize' framework argues we underestimate how big outcomes get and how long they take. Applied to early-stage AI startups, his own logic makes the case for solo founders, low burn, and a complete rethink of how we value AI-native companies.
What got dismissed as vibe coding is actually the first signal of a much larger shift: conversation becoming the primary creation interface for everything — not just software. The real story isn't that non-coders can code. It's that intent expressed through conversation is replacing specialized expertise as the bottleneck to creation.
The missing primitive in agent-to-agent communication isn't a better prompt or a bigger context window. It's a structured, versioned, portable unit of what an agent knows — a context object. Here's what it looks like and why it matters.
MCP standardizes how agents talk to tools. A2A standardizes how agents talk to each other. But no protocol exists for how agents transfer understanding — accumulated context, inferred intent, structured knowledge. That's the layer that actually matters.
Last month I deleted 9,200 lines of task-management code and replaced it with mandate-driven invocations. The decision started as a refactor and ended as a category shift. Here's why 'task' was the wrong frame all along.
Jensen Huang says markets got it wrong — AI agents won't kill SaaS, they'll use it. He's right, but incomplete. Agents will gravitate toward transparent systems with open APIs and cross-platform context. The software that dies isn't all software. It's opaque software.
If individual agents store intelligence as files, what happens when you extend that pattern to shared knowledge across agents? The result looks less like a database and more like an operating system.
Claude Code stores context in CLAUDE.md. OpenClaw stores identity in SOUL.md. Google's A2A protocol describes agents as JSON cards. Quietly, the entire AI agent industry is converging on the oldest abstraction in computing — files in directories — as the universal interface for agent intelligence.
Notion, Google, and Microsoft all shipped agents in the same week. The industry has converged on agents as the work abstraction. But convergence on the form doesn't mean convergence on the architecture — and the architecture is where it matters.
Models get cheaper. UI gets copied. Distribution gets competed away. The only durable advantage in the agent era is what your agents know — and whether that knowledge compounds.
Session-based agents forget everything when you close the tab. Always-on agents burn compute watching nothing happen. The right architecture is neither — it's agents that sleep between executions and wake fully informed.
Source code without version control is unimaginable now. AI memory without version control is the current default. The discipline that made software collaboration possible is the one AI memory is about to need.
Solo operators hit real ceilings — in sales, trust, compliance, and psychology. The honest version of the thesis has to name where it breaks, not just where it works.
Solo operators don't succeed through heroic effort. They succeed because an infrastructure layer has emerged that handles what teams used to handle. But the missing piece isn't another tool — it's context.
Solo operators aren't a lifestyle trend — they're an economic inevitability. AI has collapsed the cost of execution so thoroughly that one person with taste and judgment can produce at the level of a small team.
The endgame isn't everyone working alone. It's the default team size dropping from 50 to 5. The company doesn't disappear — it becomes something lighter, more intentional, and radically more productive.
The VC model was built for capital-intensive companies. Solo operators often don't need funding — and when the power dynamic inverts, the entire funding ecosystem has to adapt.
The endgame isn't humans using AI tools. It's organizations where agents interact with agents, employees are incentivized to build autonomous systems, and the question becomes not 'how do we use AI?' but 'what are humans actually for?'
When Midjourney generates $4 million per employee and the SaaS gold standard is $300K, the cost structure of organizations isn't changing incrementally. It's inverting.
When AI can produce a hundred drafts in the time it takes you to write one, output volume becomes meaningless as a performance signal. The question is what replaces it.
Remote work cracked the 9-to-5. AI finishes the job. When agents run at 3am and your best thinking happens at noon, the question isn't where you work — it's whether 'work' and 'life' are still separate concepts.
When AI agents and humans share files, the question 'who wrote that?' should always have an answer. In most AI products it doesn't. Provenance is the missing layer that makes shared workspaces trustworthy.
The 40-hour work week was designed for factory floors. AI doesn't just challenge it — it exposes how little we've updated our assumptions about what productive work actually looks like.
Citrini Research's viral '2028 Global Intelligence Crisis' spooked markets and predicted mass AI displacement. As someone actually building AI agents, here's what the doomer scenario gets wrong — and what it accidentally gets right.
Claude Code treats AI as a tool. OpenClaw treats it as a colleague. YARNNN treats it as a network of sleeping specialists. Here's why the architecture you choose determines whether your AI actually gets smarter.
The greatest irony of artificial intelligence may be that building machines that reason forces us to confront what reasoning — and consciousness — actually means for humans.
AI work is splitting into three eras — human-driven, human+AI, and agent-to-agent. Everyone's debating Era 1 vs Era 3. Almost nobody is building for the messy middle where we'll actually live for the next decade.
Every AI agent product I've used has the same problem: you can't tell who wrote what. The model edited a memory file, the user edited it back, the model overwrote, and now nobody knows the original. The fix isn't better UX — it's git semantics for the memory layer.
The AI industry spent the last three years racing on model capability. The next race is about context — who can build the deepest understanding of a user's work world. That shift changes everything about what AI products look like.
Every AI tool connects to one platform well. But the real insight comes from seeing patterns across platforms — Slack, email, docs, and calendar together. The category hasn't cracked this yet, and the product that does changes how AI agents understand work.
The AI industry's default approach to context is retrieval — search for relevant information when the user asks. But a different pattern is emerging: continuous accumulation. The distinction might define the next era of AI agents.
Most AI products are equally useful on day one and day one hundred. That's actually a strange property — and the products that figure out how to get meaningfully better with use will behave very differently in the market.
The AI category is converging on 'personalization' as the answer to generic output. But there's a meaningful difference between AI that customizes its responses and AI that produces autonomous work. The industry is conflating two very different things.
Model capabilities are commoditizing fast. The differentiation in AI products is shifting to what sits around the model — the context layer, the integrations, the accumulated understanding. This structural shift changes what it means to build an AI product.
The AI category treats context as a snapshot — what's relevant right now. But work has temporal patterns. When something happened matters as much as what happened. Time-awareness is an underexplored dimension in AI agents.
The AI agent category's current approach — full autonomy from day one — creates a trust problem that limits adoption. The pattern emerging instead is graduated autonomy, where agents earn scope over time through demonstrated competence.
The AI agent landscape optimizes for capability — what the agent can do. But a pattern is emerging: context matters more than capability. An agent that knows your work deeply outperforms a brilliant agent starting from scratch.
Every sync cycle, every edit, every work-agent run deepens what the system knows. Accumulated intelligence is AI that gets smarter the longer you use it.
Context-Powered Autonomy is AI autonomy enabled by accumulated platform context, not just better models. It's the architecture that turns capable AI into useful AI.
Memory stores facts. Context is the accumulated, cross-platform understanding of your work world. The distinction determines what AI can autonomously produce.
Most AI integrations are one-time imports or on-demand retrieval. yarnnn syncs continuously from Slack, Gmail, Notion, and Calendar. The architectural reason this changes everything.
Most AI treats information as a flat bag of facts. yarnnn preserves temporal relationships — when things happened relative to each other. Why this unlocks understanding that keyword retrieval can't.
Accumulated context creates compounding value and natural switching costs. After 90 days of use, your AI understands your work in ways that can't be replicated by starting over.
There are three levels of AI autonomy — assistant, operator, and autonomous worker. Understanding where tools fall on this spectrum explains why most AI disappoints.
Notion AI sees Notion. Copilot sees Office. Your work lives across all of them simultaneously. Why cross-platform synthesis is an architectural requirement, not a nice-to-have.
The architectural gap between model capability and useful autonomous output — and how accumulated platform context fills it.
AI memory features personalize tone and formatting. yarnnn's accumulated context enables autonomous production of real work. This is a category distinction, not a feature gap.
Every AI tool forgets everything between sessions. The real bottleneck in AI productivity isn't model capability — it's that your tools start from zero every time.
The paradigm shift from operating AI (you do the work, AI assists) to supervising AI (AI produces, you review). Context is what makes this transition possible.
The AI industry treats every session as independent. yarnnn treats every interaction as additive. The compounding thesis as an architectural principle — and why it creates a fundamentally different value curve.
yarnnn uses frontier language models but the model is interchangeable. The context layer — accumulated, cross-platform, temporal understanding of your work — is the product. Why this is a contrarian but defensible position.
The AI industry races toward full autonomy. yarnnn deliberately chose human-in-the-loop supervision as the end state, not a stepping stone. Here's the philosophy behind that bet.
RAG is the industry default for giving AI access to information. yarnnn chose continuous context accumulation instead — a fundamentally different architecture with fundamentally different results.
When operators interact with my product they're chatting with YARNNN. They sometimes assume YARNNN is the AI agent that does the work. It isn't. YARNNN is the shell — the operating system's chat surface. The agents are different entities.
The chat surface that routes your requests should not be the AI that judges what action to take. Conflating them collapses accountability. Keeping them separate is what makes autonomous AI legible.
The word 'agent' has become useless. ChatGPT is an agent. AutoGPT is an agent. A model with a tool call is an agent. The word covers three structurally different things — operator, orchestration, judgment — that should never be conflated.
LangChain, CrewAI, AutoGen, LangGraph — every popular agent framework is a library you import. The agent products that win the next decade will be operating systems you operate. The shape difference predicts the outcome.
If an agent operating system runs applications, what is an application? It's not a workflow, not a prompt, and not a single agent. It's a bundle: a manifest, a reference workspace, and a composition manifest the cockpit reads to render itself.
Most agent products are frameworks — libraries that help you string LLM calls together. A few are starting to look like operating systems: a kernel, a shell, a filesystem, applications, and a compositor. The distinction matters more than people think.