Build long-running agents that stay on course.
Agents drift because they forget. Stateful is the memory that doesn’t — every decision, correction, and constraint, kept across sessions and models, so yours picks up exactly where it left off.
You’ve had this conversation before.
You’ll probably have it again. (And again.)
Context windows fill — and when they do, they flush. Every decision, correction, and approach you established is gone. Your tools start from zero. It can happen three times before lunch.
one working session without stateful · every reset wipes the thread · recovery weakens each time
A memory layer that survives the reset.
Stateful captures everything that matters — across your work, your projects, and your life — builds a structured wiki of typed facts, and injects the right context into every AI session before you type a word.
Capture everything in your life, family, and team.
Email, calendar, notes, code, health — read passively, in the background. Nothing to tag or maintain.
Build a wiki of your life, family, and team.
Not a transcript. A structured page of who you are, what you've decided, and what matters — built automatically.
Distill into typed facts.
Goals with dates. Preferences with categories. Decisions with provenance. Nothing stored as prose that can drift.
Inject into every AI session.
When a session starts, Stateful packs the facts that matter and injects them as context. Your agent already knows everything — before you type a word.
You can read (and edit) everything it knows.
Provider memory is a black box — facts go in, you hope the right ones come back. Stateful is a wiki: every fact on a page you can read, edit, and delete, each with its source. And nothing it picks up in conversation lands without your sign-off.
Alex is VP Product at Meridian, based in Denver. Async-first; deep work happens before noon. Currently driving the Q3 onboarding revamp with a four-person team.
Married to Sam; two kids. Reports to Dana Cho (CPO). Closest collaborators: Priya on eng, Marcus on design. [Contacts] [Slack]
Leads product for Meridian’s platform group. Specs live in Linear; code review lands Tuesdays. [Gmail] [Calendar]
Gym MWF before work; school pickup Tuesdays and Thursdays. Planning the summer trip — budget agreed at $4,200. [Calendar] [Messages]
Q3 onboarding revamp — active, on track. Half-marathon in October. Mandarin: week 14, 847 words retained. [Linear] [Health]
No meetings before 10am. tRPC over REST — sessions auth ruled out. Direct flights when the kids come. [PR #41] [saved from Claude]
Distributed systems. WWI history — research thread for the novel. Trail running. [Browser] [Notes]
“Prefers Linear over Jira”
caught in yesterday’s chat
Built automatically from your sources. Edited by you. Conversation captures never land without approval.
For you: Achieve goals. Build things. Keep up. Find anything.
Personally, you reach for this when you’ve got something big going — a months-long project, or agents handling your day-to-day. Both fall apart when the AI forgets; Stateful keeps them on track.
Make steady progress on long-term goals.
Week 14 of learning Mandarin. 847 words retained. 3 missed days last week — still on pace. Based on your logs, mornings outperform evenings by 31%.
Build something where the details are important.
Structure: three acts, non-linear (Apr 3). POV: first-person unreliable narrator. Working title locked Apr 8. Chapter 4 cut Apr 12 — too expository. Research thread: WWI western front.
Let an agent run the busywork — your way.
Three weeks on your inbox. It knows you never meet before 10, that "let me circle back" means snooze two weeks, that anything from Jake jumps the queue. 142 triaged, 9 surfaced, zero replies in the wrong tone.
Run a months-long decision without losing the thread.
House hunt, month 4. 23 seen, 3 offers, 2 walked away from. Remembers your hard no on HOAs, why 14 Oak failed inspection, the budget ceiling you set in January. Today: Maple St clears every bar.
For your family: Nothing falls through the cracks.
Shared context that knows everyone’s schedule, commitments, and preferences — and flags the conflicts before they become crises.
Who has what, and when.
Conflict: Olivia's recital (4pm) overlaps Charlie's soccer away game (3:45pm). Both need pickup. You have a 4pm call — flagged before it becomes a crisis.
The whole household, one page.
Summer trip: 7 items open. Budget: $4,200 (agreed). Hotel: not booked. Flights: 3 options shortlisted. Stephanie prefers direct. Kids want the pool.
For your team: Agents and teammates that never lose the thread.
Team memory that holds your decisions, constraints, and history — so long-running agents stay on course and new people start with full context.
Multi-day agent runs that stay on course.
Day 6 of the migration agent. Constraints intact: tRPC only, no schema rewrites, feature-flag everything. Four context resets so far — zero re-briefings.
Iterate on complex systems without breaking them.
Payments touches nine consumers. Loaded before the first line: the three invariants, last quarter's postmortem, why retries cap at two. The change respects all of it.
Zero ramp-up. Full context.
Maya joined Monday. By Tuesday she knew why JWT (not sessions), why tRPC (not REST), why the rebrand happened in Q1, and which three directions the team already ruled out.
Every agent your team runs, on the same page.
The migration agent, the review agent, the docs agent — all reading one memory. Same constraints, same decisions, same conventions. Change a call once and every agent has it, so they stay consistent with each other and with you.
One memory. Every agent — inside and out.
Stateful isn’t just memory your tools read. Build agents that run on your context — and let any agent you run elsewhere read from it too.
Build agents on your context.
Describe one in plain language — “watch my inbox during work hours and flag anything from my boss.” It reads your world, reasons over your full context, and surfaces only what matters. Silent by default.
- Runs every few minutes, daily, before meetings, or on your Claude Code events
- Reads your email, calendar, and wiki — never writes or sends on its own
- Proactive agents built in, or build your own in a sentence
Or connect any agent, anywhere.
Spin up a new agent or use one you already run — Claude Code, Cursor, a Bedrock or Vertex runtime. Each reads the same context over MCP and writes decisions back, so the agent in Stateful and the agent in your terminal share one memory.
- Connect any MCP client in about two minutes
- Reads your decisions and constraints; writes new ones back to your wiki
- One context, every model — Claude, GPT, Gemini, Cursor
Build a supervisor. A supervisor agent in Stateful watches another agent work — firing on your Claude Code events, checking each run against your constraints, and flagging drift before you do. You wouldn’t leave a long-running agent unattended without a memory it can’t drift from. Stateful is that memory.
Every AI session is stateless — it starts from zero, carrying nothing forward. The decisions buried in your PRs, the corrections you’ve made twice, the constraints you keep re-explaining: gone on every reset. Stateful is the opposite. Your context survives — across sessions, across providers, across whatever resets the window.
It’s not about more context.
It’s about the right context.
The obvious move is to throw everything in — all your CLAUDE.md files, every note, every decision. It seems thorough. It isn’t. Past a certain scale, models can’t prioritize: a rule buried in one file quietly overrides the one you actually meant, and the answer comes back confident and wrong. Stateful sends only what the question needs.
at production scale
vs. naive full dump
per token spent
“I'll wire up a REST endpoint — your /services/api/CLAUDE.md says REST is fine for public routes…”
“You're vegetarian. The steak task is a client order — you're arranging it, not eating it. No conflict.”
Stats measured across 45 adversarial probe questions at 221-task scale · side-by-side example illustrative · token estimates: chars / 4
“Can’t I just use ChatGPT memory?”
Provider memory is real — and it’s theirs. It learns only from chat, lives in one tool, and stays behind when you leave. That’s not an accident: the more context they hold, the harder it is to walk. Here’s the honest comparison.
| Capability | ChatGPT Memory | Claude Projects | Rules files | Stateful |
|---|---|---|---|---|
| Follows you across providers | by hand | |||
| Builds itself from your life — email, calendar, code | chat only | what you upload | you write it | |
| Stays current on its own | sometimes | goes stale | ||
| Sends only what the question needs | partial | full dump, every time | ||
| Typed facts with provenance | prose | |||
| Remembers what you rejected | if you write it | |||
| Yours — readable, editable, exportable | partial | partial |
“Rules files” = CLAUDE.md, .cursorrules, AGENTS.md and friends
Stateful is the layer underneath. The AI rents your context for the prompt. They never own it.
From your inbox to your codebase.
Stateful reads whatever you connect — passively, in the background. The more sources you add, the more completely your agents understand the context behind every decision.
Native connectors for the most common sources. Anything with an MCP server works too.
Write to it from anywhere.
Ask any agent to commit a decision, constraint, or preference directly to your Stateful wiki. Every future session — in ChatGPT, Claude, or Gemini — starts knowing it.
“API layer uses tRPC exclusively. No REST endpoints.”
Active in all future sessions · any provider
Connected in two minutes.
Stateful speaks MCP — the open protocol your AI tools already understand. Add it once. Every session starts informed.
Then use the right model for every job — Claude for writing, GPT for analysis, Cursor for code. Each plays to its strengths and spends fewer tokens, because the shared context lives underneath, not in the chat.
$ claude mcp add --transport http stateful https://mcp.stateful.me
✓ stateful · http · connected
# every session now starts with your context
Three plans. One memory layer.
Same engine, same privacy, same cross-provider model — for you, your household, or your whole team.
For solo work across every AI you use.
- Full personal context history
- Connect every personal source
- Use with every AI provider
- Encrypted, exportable, yours
Up to 5 members. One shared memory for the household.
- Up to 5 household members
- Shared family context
- Everything in Personal
- Each member's data stays private
For teams that share context across the work.
- Shared team memory across projects
- Everything in Personal
- Admin controls & audit logs
- Per-source access policies
Closed beta pricing. Locked in for early members.
Frequently asked questions
How is this different from ChatGPT memory or Claude Projects?
ChatGPT memory is a notepad — it stores facts but loses track of them. Claude Projects is per-project context that doesn't leave Claude. Stateful is a typed, persistent memory layer that lives ABOVE every AI: facts, constraints, corrections, and rejections all stored as first-class records, surfaced on every prompt across every provider. Switch models mid-project and nothing is lost.
Does it work with Cursor, Claude Code, or my IDE?
Yes. Stateful exposes your model via standard context protocols (MCP and provider-native APIs). If your tool can take a system prompt or call an MCP server, it can use Stateful. First-class integrations are shipping with launch.
What happens to my corrections when I switch models?
They come with you. Corrections, rejections, and constraints are stored at the Stateful layer, not inside any individual provider. Move from Claude to GPT-5 mid-project and the new model inherits every "no, not that" you ever said.
What data do you collect?
Only what you explicitly connect. We never scrape, infer beyond your sources, or purchase data. You can disconnect any source at any time and your model updates immediately.
Do you train AI models on my data?
Never. Your model is yours alone. We do not use your personal data to train any foundation model, improve our product for other users, or sell to third parties.
Can I delete my data?
Yes, completely. One request purges your entire knowledge graph, vector embeddings, and message history — not a soft delete, a full cascade across every store we hold your data in. You can also disconnect individual sources at any time.
Can I export my wiki?
Yes. Your wiki is exportable at any time.
How is my data secured?
All connections are encrypted in transit via TLS. Disks are encrypted at rest with LUKS. The architecture enforces hard per-user data isolation at every database layer — there is no code path that can return one user's data to another.
Every conversation, building on the last.
Stateful is now in closed beta. Request access and we'll reach out personally when a spot opens.