Shared memory→
Plans, decisions and open work, kept with the project.
For everyone who builds with AI
Tortilloid is a desktop app for building with AI agents, and more than another agentic IDE. Kongo, Claude Code and Codex share one memory of your project, every change can be undone, and the work gets easier as the project grows.
Tortilloid gives your project somewhere to live. Your files, your work, your terminals, every change and Kongo, all in one window.
The Tortilloid window for one project: the file tree, an open file and Global History, with Kongo on top in its own window. Kongo fixes the file, and the patch lands in Global History. The view moves to Work Space, where Kongo finishes two more jobs. Then a terminal opens, you type run project, press Command Return, and it becomes npm start, which runs the project. You: Exports are dropping rows again. Fix that, then add retries and a CSV option. Kongo: Fixed, the same way as in March. Retries and CSV are next, and they’re in Work Space. Kongo: All three are done, and all the tests pass.
Kongo
A full system agent with your whole project to hand.
Kongo isn’t just another chatbot. Kongo is a full system agent built into Tortilloid, with your whole project to hand. Kongo finds out why something broke, builds the fix, runs the tests and shows you every step. When the work isn’t code, Kongo can organise anything to do with your email, files, websites and the information on your computer.
More about KongoKongo conversation, Why did checkout break?. You: Checkout has been failing for some customers since this morning. Why? Kongo: Found it. Last night’s change to session.js renamed the order field, but webhook.js still reads the old name. Payments go through, and the order never gets marked as paid. One test reproduces it. Want the fix? You: Yes. Then tell me what you changed. Kongo: One line in webhook.js. All 42 tests pass. It’s in Global History, linked to last night’s change, so you can undo it.
Kongo conversations. You: Codex ran out of tokens. Can you finish? Kongo: On it. Codex got through the PayPal button and the webhook. Refunds and their tests are what’s left, so I’ll start there. You: Go ahead. Kongo: Refunds are in and all the tests pass. They’re linked to Codex’s work in Global History, so whoever looks next sees how it fits together. You: Where did we get to with my budget tracker? Kongo: You finished the monthly summary on Tuesday. Spending alerts are half done: the rule works, and the email isn’t written yet. Ready to pick that up? You: Yes. Keep the email short. Kongo: Done. One line: what you spent, your limit, and a link to the month. Should it wait until morning rather than send late at night? You: Remember that game idea from June? Kongo: Yes. A small farming game where the crops keep growing while you’re away. Your notes are in notes/game-idea.md, with the three levels you sketched. Want to start with the first one? You: Yes, start with the first one. Kongo: Level one is in: a field of six plots, and a clock that keeps running while the game is closed. Run npm run dev to try it.
Tortilloid gives your agents somewhere to live. The history, the open work and the reasons behind every change are always there, so working with an agent stops being a string of one-off chats and becomes a long-term collaboration.
Ask a question and Kongo already knows. Kongo suggests the next step, remembers what you agreed and picks up where you left off. The computer from science fiction, the one we were all waiting for, finally on your desk.
And not only Kongo. The same tools give Claude Code, Codex and any MCP agent the same memory and the same way of working.
Your agents
They stay in their own windows, and share one memory with Kongo.
Tortilloid doesn’t replace Claude Code or Codex, and it doesn’t wrap them in another app. Open them in their own windows, as many as you like, and work the way you already do. Once connected, they share one memory with Kongo.
Three windows on one project. Claude Code rebuilds the orders page, Codex fixes double refunds, and Kongo reports on both. You: What did Claude Code and Codex get done today? Kongo: Claude Code rebuilt the orders page. Codex fixed the double refunds. Both are in Global History. The next step in the plan is CSV export. Want me to take it?
Your agents
CLI agents get the same memory, in any terminal.
CLI agents work the same way. Claude Code, Codex, Antigravity and anything else that speaks MCP get the same memory and the same tools, in whichever terminal you already use. One agent can pick up exactly where another stopped.
Claude Code finishes the CSV export in a terminal. Codex then writes its tests in a second terminal, starting from what Claude Code recorded.
Your agents
Connect your agents once, and every project you open in Tortilloid is ready.
You don’t move your agents into anything, and you don’t change how you work. Connect them once, and every project you open in Tortilloid is ready.
Connecting adds Tortilloid to the agent’s own settings file, the one it reads each time a session starts. Nothing else in that file changes, a backup is kept beside it, and Disconnect removes only what was added.
Kongo
Kongo runs the tools your project already uses: your tests, your build and your scripts. Add any MCP server and Kongo can use that too, from your database and design files to your own internal APIs.
Chain them together in one go. Check the design, change the code, test it and open the pull request. One request, every step.
You stay in charge. Access is granted tool by tool, once or for the whole project, and every call is recorded.
Kongo
The state, history and knowledge of your work, kept with the project.
Plans, decisions and open work, kept with the project.
Every change, who made it and why. Undo any of it.
RAG search over your code, docs and history. It runs on your Mac.
Commit and push from a conversation, with your approval.
Use the agents and models you like, and stay in charge of them.
Claude Code, Codex and others share the same project.
Choose the model for each chat, and change your mind.
Kongo can hand a piece of work to another agent.
You see the exact action and decide.
Real projects come with email, documents and research. Kongo helps with those too.
Files, websites and what’s on your computer, kept together. Kongo searches them and cites the source.
Task Kongo to manage email threads, whether they relate to a project or not. You approve every send.
PDF, Word, Excel and PowerPoint, read in place.
Your Mac does the work. Follow along, answer Kongo and start new work from anywhere.
Work Space
Every thread, plan and decision in one place. See what's moving, what's been done and what comes next, get things moving with a single click.
Simple on the surface
With Tortilloid, you mostly just talk.
Most AI coding tools still look and work like a programmer’s IDE, with walls of panels, menus and controls, most of them nothing to do with what you’re trying to get done.
With Tortilloid, you mostly just talk. Kongo gets it done and reports back in language you know, whatever your experience. Your project’s full state, knowledge and tools sit underneath, there when you want them, and every step is on the record.
Kongo
Talk to Kongo the way you would a friend or a colleague on the project. Need dates, times, code snippets, change logs or reports? Just ask.
Kongo cuts the noise.
Kongo conversation. You: When did we switch to PayPal? Kongo: 14 October. You and Codex chose it after the Stripe webhook timeouts. You: Show me the line that emails the owner. Kongo: In exportQueue.js, line 11. You: Write this week’s change log. Kongo: 12 changes across checkout and exports. Drafted and saved in docs/release-notes.md.
Tortilloid
No code needed. Real software that keeps growing for as long as you keep asking.
You don’t need to write a single line of code, or even know how. And you won’t get a demo that falls apart on day two. You get real, professional-grade working software that will always keep growing, so long as you keep asking.
Plans, decisions and history stay with the project. Work that takes months picks up where it stopped, and no one has to explain it all again.
Want Claude Code on the UI and Codex on a tricky backend? Use both, in the interfaces you already know. They draw on the same project memory and the same tools as Kongo.
Tortilloid
Your agents use the same terminals you do. Watch, and step in at any moment.
Read your project, select what matters and tell agents what to change. Open as many terminals as you like. Your agents see and control the same ones you do. Watch while they work, or step in anytime and change direction. You’re in charge.
Under the surface
Tortilloid is a surface that lives between you, your agents and your code. Every agent reads from the same context before it acts, and always writes back what it did and why. Over time, this becomes your project’s memory.
Every agent sees the same history, open work and decisions.
Each edit is a patch: checked, logged with its reason, reversible.
A vector index of code, docs and history, so agents look in the right place.
Plans live in work threads any agent can pick up.
Kongo
Bring your own API key, use the model that suits the job and switch mid-conversation. Kongo’s memory stays the same whichever you pick, and your project never lives inside someone else’s account.
Works with OpenAI, Anthropic, Google Gemini, Meta Llama, Qwen, DeepSeek, GitHub Copilot, Hugging Face, NVIDIA, Perplexity, Ollama.
A local model ships with Tortilloid. Support for the local models you run yourself, through Ollama, is on the way.
Made for building
1 of 7
Checkout had grown for four years, and nobody remembered all of it. Before touching anything, we asked what it touched and why it was built that way. Kongo answered from the code and from the history behind it.
We asked what it touched, and why it was built that way.
Kongo conversation. You: We’re moving checkout from Stripe to PayPal. What touches Stripe, and is anything there on purpose? Kongo: Four places: checkout, webhooks, refunds and receipts. One of them is there on purpose. The old subscription route stays on Stripe, because customers on annual plans still renew through it. That was decided in March, and the reason is on the work thread.
2 of 7
In Plan mode, nothing changes until you say so. Kongo laid the work out in order, we moved refunds earlier, and the plan went onto a work thread that every agent on the project can read.
Nothing changes until you say so.
Kongo conversation. You: Plan the move. Stripe stays on for existing subscriptions. Kongo: 1. PayPal button on the checkout page 2. Create and capture orders on the server 3. Webhooks for captures and refunds 4. Tests, then a flagged release 5. Refund page for support You: Refunds go before the release, not after. Then go.
3 of 7
We kept the agents we already pay for. Claude Code worked on the checkout page and Codex on the server. Both started from the same plan, and each could see what the other had done.
Both started from the same plan.
The orders-app project in the Tortilloid window, with its files in the tree and its work in Work Space. Kongo sits on top in its own window. Kongo: Claude Code is on the button and Codex has the webhooks. Neither is touching the other’s files.
4 of 7
Each patch arrived in Global History with who made it, when, and the file it touched. We could review any of it or roll it back, whichever agent wrote it.
Who made it and when, whichever agent wrote it.
The project window as the work goes on. 7 patches land one after another in Global History, each with who made it and when.
5 of 7
One test failed. PayPal can send the same webhook more than once, and our handler treated each delivery as a new payment. Far better to find that here than from a customer with two receipts.
PayPal can send a webhook twice. Now that’s handled.
Kongo conversation. You: Run the tests. Kongo: 41 pass, 1 fails. PayPal can deliver PAYMENT.CAPTURE.COMPLETED more than once, and each delivery sends a new receipt. I’d store the event ID and skip any we’ve already seen. Want me to fix it? You: Yes. Kongo: Fixed. All 42 tests pass, and the new one covers a repeated delivery.
6 of 7
Publishing is ours to approve. Kongo showed exactly what it wanted to push and where. We read it and allowed that one push, and the decision is on the record.
Kongo asks before it publishes anything.
Kongo conversation. You: Commit this and push it. Kongo: 12 files committed as “Move checkout to PayPal behind a flag”. It’s ready to push when you approve it.
7 of 7
A new developer asked why the old Stripe route still exists, and whether it could go. Nobody had to remember. The answer came from the record, with the date it stops being true.
Nobody had to remember.
Kongo conversation. You: Why do we still have a Stripe route? Can I delete it? Kongo: Not yet. It’s there on purpose, for customers on annual plans, who renew through Stripe until 1 November. After that it’s safe to remove. Want me to add that to the Work List for November?
A second opinion
One click copies a short question and our full documentation. Paste it into the agent you already use, in your project, and get a straight answer.
A home for your project, your agents, and everything you build together.
Download Tortilloid