Introducing Yohanun Guilds

Every coding agent you've ever worked with has the same disability: it starts every session from zero. Yohanun Guilds is what happened when we refused to accept that.

The wall

Yohanun exists because of an assistant that hit the stateless wall. Years before the platform had a name, there was Sile, an assistant that was genuinely useful right up until the conversation ended, and then remembered none of it. Every session was a first meeting. Every decision had to be re-explained. The intelligence was there; the continuity wasn't.

If you work with coding agents today, you know this wall intimately. Your agent helped you debug that authentication issue for two hours last Tuesday. It knows (knew) exactly why you chose that library, which approach failed, where the bodies are buried. Open a new session and ask it: nothing. You are the only memory your tools have, and you spend the first ten minutes of every session being it.

How it actually happened

We should be straight about the origin, because it isn't a product-vision story. We never set out to build a memory companion for Claude Code or Codex. We were building Yohanun itself, a governed memory platform, and building it the way everyone builds software now: with coding agents doing a real share of the work. The irony was hard to miss. We were shipping persistent, governed memory by day while our own tools woke up amnesiac every morning.

So we pointed the platform at ourselves. Our agents got names, got memory, got the session-start recall. "Eat your own dog food" is a phrase I first heard in Silicon Valley twenty years ago, and it has rarely applied this literally: the thing we were building became the thing we built it with. And it worked. Not subtly. Sessions opened oriented instead of amnesiac, settled decisions stayed settled, and the first ten minutes of every session came back to us.

For weeks this was purely internal tooling. Then, in late July, a conversation in Launchloop made something obvious: the pain we'd removed for ourselves is the pain every team using coding agents has. Guilds is that internal tooling, productised. Same platform, same walls, same kit we still use every day.

What a guild is

A guild is you, plus your agents. A named agent for each project you choose to give memory. One agent per project is the default, not a rule: an agent can run several related repositories and carry one memory across them, the way ours do. Some projects should remember, some shouldn't, and deciding that is yours. Each agent owns its memory: not a transcript dump, but graded memories it writes with hindsight at the end of a session. Decisions rank above notes. Gotchas rank above chatter. A memory that turns out wrong gets superseded, never silently edited, and a finished task gets closed. The record stays honest because it's append-only.

The names exist for a very human reason. In the early days every project was run by "Claude", and it kept looking like Claude had forgotten what we'd said a moment ago, because a single assistant carries a single set of expectations: it ought to know everything you've ever told it, everywhere. It doesn't, and no tool will. Naming each project's memory turned it into an agent, and the expectations came right. Setanta knows its project, and nobody is surprised that Setanta doesn't know a different project's history. The name is the boundary of the memory made visible. It turned the walls from feeling like memory failures into feeling like colleagues.

The walls between agents are real. Each agent's memory is owner-walled inside the platform's query layer. One project's agent cannot see another's, and that's enforced where the data lives, not requested politely in a prompt. When you want every agent to know something ("we deploy on Fridays", "the staging box is flaky"), one flag shares it to the guild's circle.

The moment it clicks

In Claude Code, a guild agent's memory arrives automatically at session start. The first thing you see is your agent reintroducing itself:

Setanta — guild memory loaded: 3 open tasks, last worked yesterday

I'm Setanta — this project's agent, carrying the memory of every
session we've had here.

Where we left off:
· Programme visibility shipped and verified on prod
· SEO canonical fix deployed — commit 6b1ac60

Still open:
· Restore-test the backup cron
· Mobile audit follow-ups for the coach section

That block is generated from the agent's actual memory: the freshest work first, then the open tasks it agreed to, then whatever else is relevant. The ten minutes you used to spend re-establishing context now happens before you've typed anything.

Outside Claude Code, the same memory is a CLI away (yohanun search, yohanun store, yohanun due), so the agent identity survives tool changes. The memory belongs to the agent, not to whichever app you ran it in.

The part that matters more than it sounds: forgetting well

Remembering everything is easy and useless. The hard problem is ranking. Guild memory decays the way work does: what you touched recently is vivid, what you haven't needed in months fades, though never to zero, and picking an old project back up revives it. Resume a thread of work after months away and its memory returns at the strength it had when you left, then ages forward normally, exactly as if the gap never happened. Your agent treats "the thing we did in March" the way you do once you're back in it: current.

And because the agent distils sessions rather than hoarding transcripts, its memory stays the size of what mattered. We measured the alternative, feeding everything into recall indiscriminately, and it makes agents measurably worse. The discipline of distillation isn't a limitation; it's most of the value.

What it runs on

Guilds is a consumer of the same Yohanun platform we build for governed, regulated AI work: hard tenant isolation, per-principal ownership enforced inside every query, an append-only memory lifecycle, and access decisions made deterministically before any model sees any context. Your guild gets that whole substrate for the price of a pip install. We use it ourselves, daily. The agents that build Yohanun are a guild on Yohanun, and half our roadmap comes from what they teach us.

The beta, honestly

Guilds is in an invite-only beta. It's free during the beta and will eventually be paid. If you join now you'll hear about that from us long before it happens, and early guilds will be treated well. We're keeping it small because we work directly with each guild at this stage, and because the product improves fastest from real use, watched closely.

If a project of yours deserves an agent that remembers it: ask for an invite. Setup is five minutes: install the kit, yohanun init, wire your first project, and your next session opens with someone who was there for the last one.