Meet Lumio
Your place for product context.
Lumio reads your codebase and builds a navigable map of how your product actually works: every journey, state, and the services each one touches. Read straight from the code, so it reflects what’s there now, not what someone remembers. No stitching together screenshots, dashboards and Slack replies. Teams navigate it. Agents query it next.
What’s considered normal today
Piecing it together
Whenever you need to understand how your product actually works, you go and discover it yourself: dashboards, old files, the one person who remembers what was built. By the time the answers come back, half the day is gone.
Then you hand it to an AI, and it synthesises brilliantly, but only from what you fed it. Two days later, that hard-won picture is buried in your chat history, and you start over. Each round adds tools and loses context.
Add agents, and they hit the same wall: they need product context too. With nowhere reliable to get it, they guess confidently. You ship it, a flow breaks in production, and the only way to find what happened is to read the code yourself. The exact job agents were meant to remove.
Where you go to find out
Making your product legible
Lumio reads your codebase and maps every journey, state and path your product actually has. Not the plan. Not the documentation. Not what someone remembers. What’s there, read straight from the code.
Situations in need of clarity
When Lumio matters
Each of these is the same thing missing: a reliable read of how your product actually works, right now. You’ll know which ones are yours.
You’ve taken over a product you didn’t build
But the people who made the decisions have moved on. Three weeks in you still understand a fraction of it, and every gap means asking someone.
You’ve put coding agents to work on the real codebase
But on the product you’ve already shipped, they rebuild features that exist and break flows nobody flagged, and the team spends the sprint cleaning up.
You’re rebuilding the product on a new system
But the old one’s behaviour was never written down, so QA has nothing complete to test against. The misses surface as production incidents, on a deadline.
Your AI support agent answers from the help centre
But the help centre documentation is thin. A customer asks about a recent change, and it replies, confidently, with the version that is no longer accurate.
Every customer runs the product on a different configuration
But how each one actually behaves, you work out by hand, one customer at a time, instead of being able to see it.
You’re scoring whether your agents do the right thing
But the golden set you score against is maintained by hand, and the product moves under it. The eval still goes green, while the behaviour it’s checking has already changed.
Frequently asked questions
Anyone who has to answer for how the product actually works, and increasingly the agents that act on it. It needs a real codebase to read, so it’s less suited to consultants without a repo, or products with little built yet.
An agent reading raw code has no more product context than a new hire: it answers once, then guesses again next time. Lumio is the one current map it can query instead of inferring. Agent-querying, via MCP, ships next.
It reads your codebase, the same read-only access you already give Cursor or Copilot, and maps how your product fits together. It only ever reads: we don’t train on it, we don’t keep a copy, and your secrets and keys are left out. The map is yours, and it’s deleted whenever you ask.
Only your team. Lumio maps your whole product, but what it surfaces stays private: we don’t share it, we don’t train on it, and it’s deleted whenever you ask.
It’s re-read straight from the code, not drawn by hand and left to rot. Re-scan, and it reflects what’s true now. That’s the difference from diagrams and docs: they’re a snapshot from the day someone last had time.
Product context straight from the code