What is Tortilloid?
Tortilloid is the surface that lives between you, your agents and your code. One shared state for everyone working on a project.
Tortilloid is a Mac app that sits between you, your AI agents and your code. It gives every agent and every person working on a project the same picture of that project: what changed, why it changed, what was decided and what comes next.
The problem
AI agents are good at writing code, but they forget. When a session ends or a context window fills up, what the agent learned goes with it. The next session starts from scratch, and you explain the project all over again.
Agents have got better at this. Many now keep notes, summaries or memories of their own. But that knowledge still lives inside the agent, not in your project. Switch to another agent, or bring in a teammate, and they start from a different picture. The history of your project ends up scattered across chat logs that only one tool can read.
The result is familiar. The same explanations, again and again. Changes nobody can account for. Decisions quietly undone because the reason was never written down. And no single place to see what actually happened.
What Tortilloid does differently
Tortilloid moves that knowledge out of the agent and into the project. The record lives next to your code, on your Mac, and it belongs to you, not to any one tool.
- Every change is recorded. Changes from people and agents go through the Patch Log, with who made them, when and why. Any one of them can be rolled back on its own.
- Plans outlive the chat. Goals, work threads, decisions and next steps live in the Work Graph, so work picks up exactly where it stopped.
- The project can be searched. Knowledge indexes code, docs and history, so any agent starts with the right context.
One shared state
Kongo, Claude Code, Codex and any agent that speaks MCP connect to the same project. Every agent and every person sees the same state. When one agent finishes, the next carries on from where the last one stopped, not from a blank page. Come back after a week and the project tells you where things stand.
Alongside Git
Tortilloid isn't a Git client, and it doesn't replace Git. Git knows what happened. Tortilloid knows why. Git keeps the snapshots you choose to commit. Tortilloid keeps everything in between, and the reasons behind it. See Tortilloid and Git.
Built for work that keeps going
Most AI tools are built for one-shot work. Ask, get an answer, start again. But software isn't one-shot and done. A project doesn't end with the first prototype or the first release you ship. Projects live. They grow, change direction and evolve, over months and years.
That is how real development teams work today, and it is how Tortilloid lets your agents work. Plans carry across days and weeks. Decisions are remembered, with the reasons behind them. One agent picks up where another stopped, and when someone new joins, the whole history is there to read.
Real agentic workflows, for everyday work
With a durable place to work, agents stop being clever one-off helpers and become useful for real, everyday work. They can take on a feature that spans a week, look after a long migration, or keep a product moving release after release.
And you don't have to learn a new way of working. Tortilloid fits the agentic workflows you already use every day, with Claude Code, Codex or Kongo. It gives them superpowers: memory that lasts, history they can trust and a shared picture of the project.
Most of it you never see
There is a lot going on underneath, but you don't have to learn it. Almost everything works silently, through your agents. They record their changes, keep work threads up to date and search the project on their own. You keep working the way you already do.
What you notice is the difference. Your agents get smarter, because they start every task with the history and decisions behind the code. Faster, because they stop rediscovering what the project already knows. Safer, because every change is recorded and can be undone. And more capable, because they can carry long work across sessions instead of starting over.
You stay in control
Tortilloid puts the project back in your hands. You choose the agents and the models, and you can change your mind at any time without losing the history. Changes can be reviewed before they land and reversed afterwards. Kongo asks before acting, see Tools and permissions. And the record of what happened is yours, on your machine, see What stays on your Mac.
Who it's for
Anyone building real software with AI. A first-time maker shipping their first app. A developer running several agents at once. A team that needs to know what changed and why. Long projects, big codebases and work that lasts longer than a single conversation. See Who it's for.
Built with Tortilloid
Tortilloid is built using Tortilloid. Every feature, every fix and every page of these docs goes through the same Patch Log, Work Graph and agents described here. It is the best test we know. If something gets in the way, we feel it first, and we fix it.
It is also why we can move so quickly. With agents that know the whole project, a change can be ready in minutes, and a request can become a tested, working feature in hours or days rather than months. Try us, see Feedback and requests.
In short
AI made writing code fast. Tortilloid makes building software with AI last. It gives your project a durable home, where people and agents share one state, every change is recorded and every decision is remembered. Your agents get better with every session instead of starting over, and your project keeps moving, effortlessly, for as long as you are building it.
Agents come and go. Your project's memory shouldn't. Tortilloid is the shared state between you, your agents and your code.