# yarnnn

> Shared memory for AI + human work

## What this site is

yarnnn is a durable memory layer that sits across the AI tools you already use. What you tell one AI is remembered for the next — kept in one shared workspace you own, written by you, your teammates (invited by email), and your AIs, with full history of who changed what and when.

Core idea: your context shouldn't reset every session or live trapped inside one vendor. yarnnn holds it as authored, attributed substrate — every fact carries provenance, and you can trace how any of it changed over time.

## Connect yarnnn to any AI (MCP)

yarnnn exposes a Model Context Protocol (MCP) server so any MCP-capable assistant — ChatGPT, Claude, and others — can read and write your memory directly.

- MCP connector URL: https://mcp.yarnnn.com
- Auth: OAuth 2.1
- Discovery: https://yarnnn.com/.well-known/mcp.json
- Three verbs:
  - remember — save something worth keeping (a decision, fact, preference). Durable, attributed, available on the next recall.
  - recall — pull what you already know about a subject. yarnnn returns the material; the host AI explains it.
  - trace — show how a recorded fact changed over time (who changed it, when, what changed) — the capability a plain storage connector cannot show.

## Developer resources

Everything an agent or developer needs to build on yarnnn, at predictable URLs:

- Developer hub: https://yarnnn.com/developers
- OpenAPI specification (OpenAPI 3.1): https://yarnnn.com/openapi.json
- MCP connector: https://mcp.yarnnn.com (transport: streamable-http, auth: OAuth 2.1)
- MCP discovery card: https://yarnnn.com/.well-known/mcp.json
- OAuth 2.1 authorization metadata: https://mcp.yarnnn.com/.well-known/oauth-authorization-server
- API errors are structured JSON: { error: { code, message, hint } } — never HTML.
- Product docs: https://yarnnn.gitbook.io/docs

## Key pages

- [Home](https://yarnnn.com): Shared memory for AI + human work
- [How It Works](https://yarnnn.com/how-it-works): The substrate loop — capture, recall, trace
- [Freddie](https://yarnnn.com/freddie): The agent that tends your memory — reads what you connect, keeps it in order, records every change (in beta)
- [Pricing](https://yarnnn.com/pricing): Free workspace + plans with included monthly usage (Free / Starter / Pro)
- [FAQ](https://yarnnn.com/faq): Product model, integrations, and pricing
- [Developers](https://yarnnn.com/developers): API, MCP connector, OpenAPI spec, and OAuth
- [About](https://yarnnn.com/about): Why we built a memory layer you own
- [Blog](https://yarnnn.com/blog): Essays on durable memory and cross-LLM work

## How yarnnn works

1. Connect yarnnn to your AI tools over MCP (or upload files / start from chat)
2. As you work, save what's worth keeping — decisions, facts, preferences
3. Any connected AI can recall that context on the next session, with provenance intact
4. Trace how any fact evolved — every change is attributed and reversible
5. Your memory compounds and stays portable; it never resets and you never lose ownership

## Why this differs from per-tool memory

- One memory across every AI, not a separate silo per vendor
- One workspace across your whole team — humans and AIs write the same memory, each attributed as themselves
- Authored and attributed, not an opaque embedding blob
- Full change history you can trace, not a flat key-value store
- Yours to own and export, not locked inside one platform

## Freddie — the agent that tends your memory (in beta)

Beyond plain memory, yarnnn runs an agent named Freddie who tends your substrate. Today he reads what you connect (Slack, Notion, files), keeps your memory in order, checks work against rules you write, and records every change so you can trace it — all reversible, attributed, and yours to verify. He only ever does as much as you allow: he goes ahead within your rules, asks first when it's bigger than that, and waits for more when something's missing. Taking action out in the world on your behalf is the next horizon, earned on the record rather than switched on. This is an optional upgrade, currently in beta — the memory layer is valuable on its own. See https://yarnnn.com/freddie.

## Platforms supported

- Any MCP-capable AI (ChatGPT, Claude, and others)
- Slack
- Notion

## Pricing summary

- The workspace and your memory are free forever — files, chat, context reachable from any AI via MCP. No feature gates: plans set an included allowance and a couple of ceilings (connector history, connector count), never a feature lock.
- Plans: Free ($0), Starter ($19/mo), Pro ($49/mo). Each paid plan includes a monthly usage allowance for the optional operation; usage is metered at transparent rates and readable line by line. Beyond the allowance, top up any amount from $5 (top-ups never expire); hard stop when allowance and balance are exhausted.
- Budget cap (separate from the plan): you set a monthly ceiling per operation and the agent paces its own work to stay under it. Two guardrails: a budget ceiling you plan, and a zero-balance floor that pauses without losing anything.
- Every workspace starts with a $3 usage balance — enough to feel the loop before you spend a cent.

## Feeds and discovery

- Developer hub: https://yarnnn.com/developers
- OpenAPI spec: https://yarnnn.com/openapi.json
- MCP connector: https://mcp.yarnnn.com
- MCP discovery card: https://yarnnn.com/.well-known/mcp.json
- Blog: https://yarnnn.com/blog
- RSS: https://yarnnn.com/blog/rss.xml
- Sitemap: https://yarnnn.com/sitemap.xml
- FAQ: https://yarnnn.com/faq

## Recent blog posts

- [The Open Source Agent Wave Needs A Judgment Seat](https://www.yarnnn.com/blog/the-open-source-agent-wave-needs-a-judgment-seat): 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.
- [You Don't Automate Taste — You Make It Supervisable](https://www.yarnnn.com/blog/you-dont-automate-taste-you-make-it-supervisable): Anthropic named research taste — judgment in choosing goals — as the last thing that doesn't automate. The answer isn't to scale until taste emerges. It's to build a substrate where taste is authored, attributed, retained, and calibrated against outcomes. That's a different bet than waiting for judgment to fall out of a bigger model.
- [GEPA and the Limits of Self-Optimization Without Outcome Truth](https://www.yarnnn.com/blog/gepa-and-the-limits-of-self-optimization): 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.
- [Per-Workspace Sovereignty Is a Safety Property](https://www.yarnnn.com/blog/per-workspace-sovereignty-is-a-safety-property): Anthropic's governance worry is about labs verifying each other to avoid a runaway race. YARNNN never inherits that problem, because of one structural property: every workspace is sovereign, every self-improving loop is per-operator, and the blast radius is one operator's budget. Sovereignty isn't just a privacy stance — it's what keeps the recursion bounded.
- [The Bottleneck Moves to Oversight](https://www.yarnnn.com/blog/the-bottleneck-moves-to-oversight): When AI does the implementation, the bottleneck doesn't disappear — it moves. Amdahl's law says the constraint shifts to the part that didn't speed up: human review and prioritization. The company that wins the next decade isn't the one with the best agents. It's the one with the best oversight substrate.
- [Draw the Autonomy Line at Goal-Choice](https://www.yarnnn.com/blog/draw-the-autonomy-line-at-goal-choice): Anthropic identifies goal-choice as the threshold where AI self-improvement gets dangerous. YARNNN draws its autonomy boundary exactly there: the Reviewer improves how and when it acts, never why. That line is a deliberate architectural decision, not a missing feature.
- [A Self-Improving Loop You Can Actually Watch](https://www.yarnnn.com/blog/a-self-improving-loop-you-can-actually-watch): The frightening version of AI self-improvement is an agent that authors its own success metric. YARNNN's Reviewer authors its own cadence — but improves against a ground-truth file it can't write, inside a budget it can't raise, leaving an attributed revision for every change. That's a self-improving loop with the safety properties built into the substrate.
- [Programs Are More Than Skills](https://www.yarnnn.com/blog/programs-are-more-than-skills): 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.
- [Personal Automation Daemon vs Operations Cockpit](https://www.yarnnn.com/blog/personal-automation-daemon-vs-operations-cockpit): 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.
- [Self-Improvement Is Not Self-Calibration](https://www.yarnnn.com/blog/self-improvement-is-not-self-calibration): 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.
- [The Reviewer Seat Is What Single-Agent Architectures Can't Add](https://www.yarnnn.com/blog/the-reviewer-seat-is-what-single-agent-architectures-cant-add): 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.
- [What 224B Tokens Per Day Tells You About The Agent Market](https://www.yarnnn.com/blog/what-224b-tokens-per-day-tells-you-about-the-agent-market): 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.
- [Hermes Agent vs YARNNN: Same Substrate Philosophy, Different Bet On Autonomy](https://www.yarnnn.com/blog/hermes-agent-vs-yarnnn-same-substrate-different-bet): 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.
- [The Schedule Is Not A Calendar: Cadence Framing For Recurring AI Work](https://www.yarnnn.com/blog/the-schedule-is-not-a-calendar): 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.
- [What Should An AI Cockpit Actually Show?](https://www.yarnnn.com/blog/what-should-an-ai-cockpit-actually-show): 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.
- [Why Compact Index + On-Demand Read Beats RAG For Persistent Agents](https://www.yarnnn.com/blog/why-compact-index-beats-rag): 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.
- [Filesystem-As-Memory: How To Cut Your AI Token Bill By 70%](https://www.yarnnn.com/blog/filesystem-as-memory-cut-your-token-bill): 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.
- [Why Most AI Agents Will Never Trade For You (And What's Required For The Ones That Will)](https://www.yarnnn.com/blog/why-most-ai-agents-will-never-trade-for-you): 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.
- [Why Owning Your Agent's Memory Isn't Enough](https://www.yarnnn.com/blog/why-owning-your-agents-memory-isnt-enough): 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.
- [The Outcome Loop: How An AI Reviewer Learns From Real P&L](https://www.yarnnn.com/blog/the-outcome-loop): 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.