Tortilloid

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.

Kongo

Meet 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 Kongo

Kongo 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.

Coding together.

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

Keep the agents you already use.

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

Or stay in the terminal.

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

No new app to learn.

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.

  • Use them on their own. Claude Code and Codex stay in their own windows, exactly as they are. Open as many as you like.In their own windows, exactly as they are.
  • Use them side by side. Put Claude Code on the UI and Codex on the backend. Each can see what the other has done and which files are in use.Each can see what the other has done.
  • Let Kongo run them. Or ask Kongo to hand work to them and report back. Kongo codes too, on whichever model you choose.Kongo hands work over and reports back.
  • Switch at any point. When an agent runs out of tokens, another picks up the work thread and carries on.When one runs out of tokens, another carries on.

Connected Agents

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.

Claude Code

Status
Connected
Installed as
Command-line tool, Desktop app
Settings file
~/.claude.json
Instructions
CLAUDE.md in this project includes the Tortilloid guide
ReconnectDisconnectUpdate guide in CLAUDE.md

Codex

Status
Connected
Installed as
Command-line tool, Desktop app
Settings file
~/.codex/config.toml
Instructions
AGENTS.md in this project includes the Tortilloid guide
ReconnectDisconnectUpdate guide in AGENTS.md

Kongo

Plug in anything.

  1. terminalnpm test42 passed
  2. postgresOrders from last week318 rows
  3. figmaRead the checkout frame3 states
  4. emailFind the supplier thread12 messages
  5. githubOpen a pull request#128
  6. stripeCreate a test invoiceAsks first

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 spec.

Code with any model
Kongo is a full coding agent on whichever model you like, even a local one. Switch between Kongo and other agents at any point, and the work carries on.
Bring your own model
Use your own keys with the providers you choose. New models appear as providers report them.
Local model as standard
A local model ships with Tortilloid, so Kongo can keep working wherever you are.
Interrupt and steer
Stop any turn, or send a message into a running one to correct course.
Fast
Knowledge finds the right files first, and prompt caching keeps long sessions quick.
Ultra-long tool chains
Kongo keeps going through long runs of tools. Work mode carries on through a whole plan.
Open and transparent
Built on OpenCode 2, the open-source agent framework, and extended by us. You see what Kongo does as Kongo works.
Document handling
PDF, Word, Excel, PowerPoint, OpenDocument and RTF, read as text. Scanned pages can be read by eye.
Managed terminals
Named, visible terminals that you and Kongo share, with output Kongo can search.
Environment bootstrap
Tortilloid installs Kongo’s engine for you. Kongo then sets up each project’s tools in those terminals.
Subagents and orchestration
Hand work to focused subagents and other agents, or schedule it for later.
Planning
Plan mode maps the work before anything changes. Plans live on as work threads any agent can pick up.

Everything your project needs.

The state, history and knowledge of your work, kept with the project.

Shared memory

Plans, decisions and open work, kept with the project.

Patch Log

Every change, who made it and why. Undo any of it.

Knowledge

RAG search over your code, docs and history. It runs on your Mac.

Git

Commit and push from a conversation, with your approval.

Everything your agents need.

Use the agents and models you like, and stay in charge of them.

Any MCP agent

Claude Code, Codex and others share the same project.

Any model

Choose the model for each chat, and change your mind.

Delegation

Kongo can hand a piece of work to another agent.

Permission cards

You see the exact action and decide.

Everything around the work.

Real projects come with email, documents and research. Kongo helps with those too.

Organise anything

Files, websites and what’s on your computer, kept together. Kongo searches them and cites the source.

Email

Task Kongo to manage email threads, whether they relate to a project or not. You approve every send.

Documents

PDF, Word, Excel and PowerPoint, read in place.

Your phone

Your Mac does the work. Follow along, answer Kongo and start new work from anywhere.

Work Space

Where the work lives.

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

No cockpit.
Just real conversations.

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

If you can use ChatGPT, you can use 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

If you can explain it, Tortilloid can build it.

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.

Long projects become possible.

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.

Many agents become simple.

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

Deliberately not a code editor.

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.

AI that gets betteras your project grows.

Under the surface

An intelligence environment for your project.

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.

  1. 01Shared state

    Every agent sees the same history, open work and decisions.

  2. 02Governed changes

    Each edit is a patch: checked, logged with its reason, reversible.

  3. 03Project intelligence

    A vector index of code, docs and history, so agents look in the right place.

  4. 04Work that carries on

    Plans live in work threads any agent can pick up.

KKongoClaude CodeCodexOpenCode+Any MCP agentStateful contextMemoryWork threadsKnowledgePatch logEvery decision rememberedWork across sessionsAgents find anything, fastFix it fasterTortilloidYour projectGoverned patchesYour codefiles · git · your editor

Not another chatbot.

Kongo

Any model. Zero lock-in.

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.

A local model ships with Tortilloid. Support for the local models you run yourself, through Ollama, is on the way.

Made for building

For everyone with something to build.

1 of 7

We had to move checkout off Stripe.

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

Kongo wrote the plan. We changed one line.

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

Claude Code took the button. Codex took the webhooks.

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

Every change landed with a name on it.

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

The tests caught a bug we’d have shipped.

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

Nothing went out until we said so.

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

Months later, the why was still there.

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.

For developers

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

Ask your own agent if Tortilloid is right for you.

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.

Make yourself
at home.

AI lives here.

Tortilloid

A home for your project, your agents, and everything you build together.

Download Tortilloid
Overview