THE STATE LAYER FOR AGENT-NATIVE DEVELOPMENT
Git remembers what changed. OpenLotus remembers why.
GitHub is the remote home for your code and collaboration. OpenLotus is the remote home for your context and agent collaboration. New machine, new IDE, new hardware. Your code follows you through GitHub. Your context follows you through OpenLotus.
While you slept, your agent shipped — every change, and why.
Remember the onboarding checklist from last week? Claude skipped it two prompts ago when you pivoted to billing. Tracked as drift — original plan attached.
re-queue it? reply: yes / show plan
Approval requested: rewrite sessions table — high risk.
Drift: your agent edited files you didn't ask for
Recorded with evidence before it spiraled. Review it…
New session, zero re-explaining
Map read replaced the full repo scan. 41 decisions carried over…
Same strategy failed twice — flagged
Third retry blocked until the approach changes…
Works with your agent environment today
No plugins. The skill drops into any terminal agent; the MCP server talks to anything that speaks MCP. Your local git is the first reality source.
Why OpenLotus exists
Your agent forgets.
The bill remembers.
Real posts from real developers on Reddit and X. Every X card links to the original.
35% of your context window is gone before you type a single character
69.2K tokens pre-loaded. Rule re-injection eats ~46% of context after ~30 calls.
Your AI coding agent forgets everything the moment you close the terminal
Every conversation. Every decision. Every bug fix. Gone.
Every session starts blind
Tens of thousands of tokens burned from zero, every single time. Run a second agent and it undoes what the first one did.
AI coding agents have a context problem. Not a model problem.
The issue isn't the model's capability, it's the context it starts with.
Your coding agent forgets everything about you every session
It doesn't know I always grep first, read the test file, then edit. You fix the same mistake session after session.
A model can hold 1M tokens and still meet you for the first time every morning.
Capacity isn't memory. The model has room but no recollection.
of agent tokens lost to re-exploration (SWE-bench study)
tokens loaded before typing a word (measured)
per-query cost with structured memory vs dumps
Your whole project, in one place.
Research, plan, build, learn. OpenLotus turns the work you already do into a plan you can trust.
Three surfaces, one ground truth
Progress map, dashboard, and agent workspace all read the same record of your real work, so nothing gets re-explained.
It watches what you build
Files you touch, decisions you make, work you haven't committed yet. The map fills itself from your actual week.
Momentum you can see
See the week form as it happens. Know what moved, what stalled, and what's next.
Your work stays yours
No repo permissions, no scanning, no exports. OpenLotus lives next to your editor, not in your way.
How OpenLotus works.
PairOne CLI command connects OpenLotus to the codebase you're building in. No repo permissions, no scanning.
Watch Files you touch, TODOs you leave, decisions you make. The progress map fills itself from your real week.
ActAsk your agent what's next. It reads the same ground truth you do. No guessing, no re-explaining.
One record.
Three surfaces. One ground truth.
Progress Map
One living tree, shared. What you planned, decided, and changed — visible to you and your agent.
Same tree your agent reads. When it drifts, you catch it here first.
- You and your agent see the same plans, decisions, and changes
- Drift shows up when the agent heads in the wrong direction
- Your context lives in the map, not just the chat window
Dashboard
Your week, summarized.What changed, what's drifting, and what to do next. Written for a founder, not a project manager.
- Weekly summary written for you, not a project manager
- What changed, what drifted, what to do next
- Monday readout, ready when you are
Agent Workspace
Your agent, in context. The agent reads the same ground truth you do, so nothing gets re-explained.
- Your agent reads the same ground truth you do
- Tool calls you can trace back to their source
- Follow-up suggestions based on what just happened
Connect your agent
Your agent, connected. Pair in one command and your coding agent reads and writes the same progress map you do — over MCP, with zero repo permissions.
- Pair your local codebase in one command: npx openlotus pair
- MCP keeps your project state live in every session
- No repo permissions needed — ever
All three surfaces, live — map, dashboard, workspace.
This week's focus
Ship the pairing flow.
Checkpoint: browser pair works end to end on production. Every number below is pulled from the progress map — the same tree your agent writes to.
Approvals · 1 waiting
Rewrite sessions table high risk
One command to pair. Nothing to babysit.
Everything you need to move research, plan, build, and learn forward without leaving your editor.
Pair in one command
Terminal opens your browser, you pick a project, the repo links itself.
Live, from your editor
The record updates as you work. No exports, no sync buttons, no busywork.
CLI-first
One command to pair. MCP to keep it live. Docs and API when you need them.
Private by default
OpenLotus reads work signals, never your code content. Zero repo permissions.
Your stack, already connected.
One control layer, many windows — Slack, email, dashboard, map, and your agent all read the same project state.
Connect your agentThe old way vs. proof.
The difference between what the human intended, what the agent believes it did, and what the software actually became.
Scattered tools
The usual way
OpenLotus
One record
Built around your real week.
OpenLotus turns the work you already do into a plan you can trust. No extra data entry, no busywork.
1 command to pair your environment.
3 surfaces, one record.
0 repo permissions, ever.
What early builders say
Founders who paired their environment and stopped re-explaining.
Solo founder Building an AI tool
My agent said auth was done. OpenLotus flagged it as drift — zero tests, three open TODOs, evidence attached. I caught it before customers did.
Indie hacker Shipping weekly
Monday starts from the shared record, not a full repo re-scan. My agent reads past decisions instead of asking me to re-explain the week.
Platform builder Developer tools
Switched from Cursor to Claude Code mid-project. Decisions, constraints, and history came along through MCP. Zero re-explaining.
Product lead Small team
An agent requested a live table drop on a Friday. The Slack alert carried the evidence, I hit reject from my phone, and the decision is on the record.
vibe-to-ship.
A drop-in skill that turns your agent into a graph-engineered builder. It breaks work into clear tasks, runs them in parallel only when they must wait on each other, and checks its own work with a fresh pair of eyes.
On its own it’s powerful. Paired with OpenLotus state, every plan it makes is anchored in your real repo and every result lands where you can see it — a system you can’t get from a plain chat.
Install the skill, then say “set up OpenLotus” and it wires the rest. Or do the three copy-pastes by hand — same result, one time. See both paths.
Free. Drop-in skill. Works anywhere.
Wire your agent in.
Three steps, one time.
OpenLotus lives in your agent, not in another browser tab. Paste two small files, run one command, and every session from now on reads and writes your project state automatically.
- 1Pair your local repoTerminal — run inside the repo you want to link
npx openlotus pairOpens your browser to pick a project (or create one). No flags, no passwords in the terminal.
- 2Register the MCP serverMCP config — save as .mcp.json (Claude Code) · .cursor/mcp.json (Cursor) · opencode.json (OpenCode)
{ "mcpServers": { "openlotus": { "command": "npx", "args": ["openlotus", "agent"], "env": { "OPENLOTUS_BASE_URL": "https://www.openlotus.io" } } } }{ "mcpServers": { "openlotus": { "command": "npx", "args": ["openlotus", "agent"], "env": { "OPENLOTUS_BASE_URL": "https://www.openlotus.io" } } } }Tells your agent how to launch OpenLotus. Save it, then restart the agent — the tools appear in every session after that.
- 3Give your agent the rulesAGENTS.md (project root) — paste once into the file, not into chat
## OpenLotus loop (standing rules) Project state lives in OpenLotus via MCP tools: get_memory, get_reality, get_drift, record_decision. The founder sees the same data on the web dashboard. 1. Boot: at the START of any work session, call get_memory + get_drift before planning anything. Surface drift findings to me first. 2. First prompt after setup: if this session already holds project context (you were just given the goals, stack, current state, or prior decisions), record it all into OpenLotus now — record_decision for each choice, write_scratchpad for context that is neither, manage_tasks for open work — so OpenLotus never starts from scratch. Do this once, not every turn. 3. Decisions: whenever a direction choice is made (stack, scope, schema, tradeoff), call record_decision immediately — title + why. 4. Reality check: after meaningful work, call get_reality; mention surprises. 5. PROGRESS.md: keep it in sync with the map after each milestone. 6. Stale > silent: if context is missing, call get_memory again — never guess.## OpenLotus loop (standing rules) Project state lives in OpenLotus via MCP tools: get_memory, get_reality, get_drift, record_decision. The founder sees the same data on the web dashboard. 1. Boot: at the START of any work session, call get_memory + get_drift before planning anything. Surface drift findings to me first. 2. First prompt after setup: if this session already holds project context (you were just given the goals, stack, current state, or prior decisions), record it all into OpenLotus now — record_decision for each choice, write_scratchpad for context that is neither, manage_tasks for open work — so OpenLotus never starts from scratch. Do this once, not every turn. 3. Decisions: whenever a direction choice is made (stack, scope, schema, tradeoff), call record_decision immediately — title + why. 4. Reality check: after meaningful work, call get_reality; mention surprises. 5. PROGRESS.md: keep it in sync with the map after each milestone. 6. Stale > silent: if context is missing, call get_memory again — never guess.
Your agent re-reads this file every session on its own. (Claude Code also reads CLAUDE.md — same block works there.) Do this once; never paste it into a prompt again.
Studio for teams
Three harnesses. One record.
Your backend dev runs Claude Code, your frontend dev runs Cursor, your contractor runs Codex. Without a shared record they re-learn the same codebase and contradict each other by Friday. Studio puts all three seats on one permanent map: same decisions, same constraints, same drift.
A decision recorded Monday is read by every agent all week, on any harness.
Constraints are shared, so one agent cannot silently violate what another was told.
When any agent diverges, the finding lands on one dashboard with evidence attached.
Same record. Same price. Years from now.
We never punish persistence. The record is free forever — flat prices the relationship, products and seats scale.
Free
The permanent record
1 product · full history in detail forever · chat, MCP & skill · progress map & dashboard
Pro
For growing products
3 products · Slack alerts · priority support — flat, fair use
Studio
For teams and agencies
Unlimited products · 3 seats · everything in Pro · priority support
FAQs
Your questions answered
Need more help? Contact us
Build with momentum.
Pair your environment in one command and let OpenLotus turn your real work into a plan.