Origami Code

The Best VS Code AI Harness

🌐 Website • 📖 Docs • 🧩 Marketplace • ⭐ GitHub

What's new in 0.4.184

• Elastic engines. Every chat keeps its own engine, so one failure never stops the others. Hidden chats now cost close to nothing: they drop to a lower priority, give back memory, and park after 20 minutes. Your next message restores a parked chat with byte-identical requests, so the prompt cache still hits. In our test, 6 idle big chats went from 2.63 GB to 0.57 GB of memory in use.
• New chats start at once on a spare engine that is already running.
• Plan mode works: the plan agent writes a plan file and ends with an approve / revise review.
• Agent map: every sub-agent and its own sub-agents, in tier columns, live.
• Drop to attach: drop a file from the VS Code explorer into the composer.
• Cache warming is off by default and now really works when you turn it on (each warm is billed as a cache read).

What's new in 0.4.175

• Big chats open fast. A large chat opens in about a second, and a long chat no longer pauses at the end of a reply.
• Nests (off by default): start a chat on one computer and continue it on another, over Origami's own relay.
• Artifacts: your agent can make a page, a plan or a report for you, and every version is kept.
• Your Claude subscription (experimental): use it as a model, with Origami's own tools, sub-agents and undo.
• Fork: make a copy of a chat, next to the original, to try a different direction.
• Find: search the whole chat, not just what is on screen.
• Schedules: Crons and Loops are now one item, with one place to see every scheduled run.

This harness is built from the ground up on the following foundations:

Features

Multiple Chats, Multiple Models, Full Control

• Every chat picks its own connection, model and sub-agent from a single dropdown.
• Local, self-hosted servers, providers and lab APIs all sit in the same list.
• Signed-in accounts show their credit use and reset timer under the composer.
• Closing a chat pane does not end the session -> the agent keeps working.

Charts in the thread, and agents that talk to each other

• Have alot of data to review? Have your Model make a chart of it in chat
• Each session can see one another and send each other messages
• Great for handovers, sub contracting work to cheaper models and larger collaborations
• It picks the work up on its next turn. A model with no vision of its own can be handed a vision sub-agent.

Nothing hidden, and a session that closes properly

• Every action and every thought stream is on the record (collapsed by default)
• Open when you want to audit a turn.
• The todo pane tracks the agent's plan as it moves.
• Tell it to wrap the session and it writes the handoff and the wiki depth, so the next session starts already knowing where you left off.

A memory graph, not a second app

• Your workspace knowledge base drawn as a graph.
• Filter the nodes, hover to light up the links, click one to read the page inline with its tags and date.
• Nothing else to install and nothing to sync.

Folds — a board per repo, an agent per worktree

• Spec a ticket, launch an agent on it, and that agent works in its own isolated git worktree.
• Your working tree stays untouched
• You review the diff and apply it on your command, never before.
• Any local git repo can go on the board, and you switch checkouts and branches from the same screen.

Repo maps you can walk through

• Remap a repo and Origami draws it
• Components by kind, the pillars they belong to, and the flows that cross them -> pan, zoom, filter, click a box for its connections or a flow to trace it end to end.
• Key files come with a line of summary each. It is built for both readers: you, and the agent that needs to orient before it touches the code.

Sub-agents you can actually watch

• Delegated work gets its own list —> running, done, errored
• See the model and the wall time for each one.
• Open any of them and read the full transcript with its findings, during the run or long after it finished.

Bots built to your spec

• Define your own bots -> a name, a model, a tool set, a memory setting and a step budget.
• Each one runs in three places —> its own chat, a collab room, or as a sub-agent
• And any of them can be marked as a vision agent for when you need a spare pair of eyes.

Loops

• Start one from the composer with /loop <interval> <prompt> and it re-runs on that interval.
• Loops survive a window reload —> each re-arms itself when its chat reconnects,
• Want to end a loop but come back later? mark it as persistent and it stays there dormant, waiting.

Crons — scheduled runs with the editor closed

• A cron is a real OS scheduled task, it fires with VS Code closed, unlike a Loop.
• See every job and when it next runs, and pick the connection and model each one calls.
• Schedules live in .origami/crons.json, tracked in git (git is the undo.)

A browser the agent can drive

• Fully ocmpatible with the integrated browser -- opens a URL or a local page, reads it and clicks through it
• Permissioned in case you dont want it
• Point it at your own dev server and the agent can check its own work.
• Every chat exports from the composer, so a session can be handed to anything.

Insights — see what the model is actually fed

• Every file that gets prepended to your prompt, with its character count, its token estimate and its share of the total.
• Override the base prompt, restore the default, or add your own file.
• Cache hit ratio for the session and across the last hundred runs sits right underneath.

Insights — the assembled payload, part by part

• Expand the last turn and see exactly what left the engine: each assembled part with its size, which ones ride as a tail after the messages, the final system block, and every tool schema offered with the characters it spends.

Labyrinth — where the tokens went

• Labyrinth indexes every run: tokens in and out, raw against real after cache, cache read against write, and spend split both by category and by delegated sub-run.
• Three views of the map, an inspector for any step, and the whole thing exports to HTML.

Skills

• Skills are markdown files the agent loads when the task calls for one. -  Search the installed set, read what each does, and edit any of them in place without leaving the pane.

Tools, and the context they cost

• Every tool sits in one of three states: Loaded :  so its schema goes out with every request;  Deferred : so it costs one catalog line until the model searches for it; Off : Session never sees it, no context as if it never existed.
• Scaffold a new tool from the built-in template, and turn on code mode to let the model reach several tools from one script.

MCP servers from the UI

• Add a server from the pane and it is written to the config you choose and connected straight away, with no session restart.
• Disable, disconnect or remove it from the same card.

Plugins

• Plugins follow the open agent-plugins standard:
• Point at a folder and a valid manifest brings its skills and its MCP servers along with it.
• A manifest that does not parse is refused with the parser's own message.
• Toggle a plugin off without deleting it.

Plays well with your other assistant

• Origami is a side panel and a set of editor tabs, not a takeover of your window.
• Claude Code can sit right next to it in the same workspace
• Same files, same repo, your call which one gets the job.

Nests — one chat on all your computers

• Join your computers ("desks") over Origami's own relay, and start a chat on one desk, then continue it on another.
• Add a desk with a QR code or a key you paste. Both desks check the same 6-digit code before they join.
• The relay only ever sees encrypted data. It has no accounts and stores nothing.
• Nests is off by default. Nothing dials the relay until you turn it on.

Artifacts — pages your agent makes for you

• An agent can publish an artifact: a page with its own styles and scripts, a plan or a report.
• The chat shows an artifact card with Open, and the page opens in the VS Code browser, in a sandbox, on your own computer.
• Every version is kept, so you can go back to an earlier one.
• The Artifacts pane lists all your artifacts and their versions, with when each one last changed and which desk made it.

Getting started

1. Install Origami Code from the VS Code Marketplace.

2. Open it from the activity bar — the crane icon — and the panel docks on the right.

3. Add a connection. Pick a local or self-hosted server, a provider, or a lab account, then paste a key or sign in. Everything you have connected stays visible in one list, with usage and reset timers where the provider reports them.

   

4. Run /firstfold in a new chat. It scans the workspace, writes an AGENTS.md your agent reads every session, creates the project folders, seeds a wiki index and starts a rolling HANDOFF.md — narrating each step as it goes.

   

5. Start working. Chat as you are, or open the Folds board, add a repo and launch your first fold.

Support the project

Origami Code is free, has no ads and sells you nothing. If it saves you time, you can throw something in the tin.

License

Free to use; not for resale, and not for resale as an adaptation — see LICENSE.