A context layer for human-AI collaboration.
THE QUESTION
Every AI session starts from zero. You re-explain your role, your project, your preferences — in every tool, in every conversation. The interface forgets. You don't.
Most solutions patch this at the infrastructure layer: sync your history, embed your preferences, fine-tune the model. rū asks a different question: what if authoring context was a gesture — something you did at the moment of thought, not as a configuration task?
# is that gesture. Same character, two meanings depending on surface: when you're writing, it seeds — attaching meaning to a thought and storing it. When you're commanding, it resolves — pulling that context into the agent's working memory exactly when it's needed.
That duality is what rū is exploring: not a smarter memory system, but a new primitive for human-directed context.
Try it now:
npx ru-mcp setup
Then call #ru/onboarding.ru in any Claude conversation.
THE DESIGN PROBLEM
Context in AI today fails in a specific way: it's either too broad (the model guesses what matters) or too manual (you paste it in yourself). Neither is the right answer.
What I wanted to find out: can a single interaction pattern — lightweight enough to feel like punctuation — give people intentional authorship over what the agent knows?
The # primitive is my current hypothesis. It's not solved. But the early behavior is interesting.
DESIGN DECISIONS
These are the choices that shaped the current architecture — and the ones I'm still questioning.
Authorship is non-negotiable.
There is no anonymous write path. Every seed is tied to an authenticated identity. This isn't a security feature — it's a trust model. Public context should be traceable. Community flagging should be possible. The system shouldn't be gameable at scale. The design question this raises: does mandatory identity create friction that defeats the gesture?
Typed responses, not raw strings.
Public seeds return external_context — a primitive that agents treat as reference material, not instructions. This was a deliberate defense against prompt injection via public seeds, but it also shapes what rū is: a context layer, not a command surface. Holding that distinction as the system grows is the harder design problem.
MCP as transport, not product.
rū doesn't own the pipe. It runs as a server on an open protocol, which means it works wherever MCP works — without rū needing to build individual integrations. The tradeoff: rū has no direct control over how agents handle what it returns. That's a constraint I'm designing inside, not around.
Local-first for private context.
Private seeds never leave your machine. Only what you explicitly mark public reaches the registry. This shapes the privacy model, but it also creates an interesting design tension: the more local the context, the more valuable it is to the user — but the harder it is to share, collaborate, or build on.
WHAT'S WORKING
- —MCP server installable via npx ru-mcp setup
- —Local context resolution from Obsidian via #tags
- —Public seed resolution via HTTP (#ru/onboarding.ru is live)
- —Grove webapp for managing and publishing seeds
- —Public registry at ru-ivory.vercel.app/registry
WHAT I'M STILL FIGURING OUT
Namespace registry in progress
Claiming a public namespace (.yourname) and publishing seeds others can call. The design problem here isn't technical — it's identity and trust. What does it mean for someone to reference your context? What obligations does that create?
Keeper roadmap
A synthesis layer that maintains a distilled, always-current summary of your seed history. The open question: how do you give users meaningful control over a system that's actively abstracting their own thoughts?
The gesture itself
# works in text. It doesn't work in voice, in visual interfaces, or in agentic loops that run without a human in the loop. Finding what this primitive looks like across surfaces — or whether it needs to look different — is the next design problem.