Origami Labs

Local First Agent Harness

AI built for building on hardware you own.

The problem

Everything funnels you to rented tokens

Almost every coding agent points you straight at hosted model-rental services; the model already running on your own machine is an afterthought nobody optimises for. Token pricing only gets worse as agents do more. Owning your own compute isn't a nice-to-have. It's imperative.

Our stance

Local-first, cloud-optional, for real

We flip it. The GPU under your desk is the default path, tuned to be fast and first-class. The cloud is still one click away the moment you want it: opt-in, never assumed. Your repo stays on disk, and the work runs with no account and no connection.

Download

Get Origami Code Free on the VS Code Marketplace · Windows x64 and Apple Silicon.

A guided look at the app.

Four things worth a closer look.

Past the one-line list on the Overview tab, here is what these features actually do.

01 · Insights

See exactly what the model received

Every run unrolls as a step ledger: prompts, thinking, tool calls and replies, each with its real token cost. Pin any step to inspect exactly what went to the model and what came back. Nothing summarised, nothing hidden.

02 · Agents that message each other

Two running agents can hand off a note

A running session can send a short message to a different, already-running Origami session on the same machine — another VS Code window, say. It is not a subagent call: no parent, no shared memory, just a note. Messages default to a 2,000-character cap; the sender can ask for more, up to 10,000. If nobody is watching the target session, delivery is refused, not silently dropped.

03 · Memory Graph

Your foldered memory, drawn as a map

The Memory Graph draws your wiki as a force-directed map, coloured by folder. Filter it live: every term matches a page's title, snippet, tags or path, hits only. Click a card to preview the page without leaving the graph.

04 · Subagent routing

Delegate to a caged agent, not a blank cheque

The task tool spawns a subagent under one of six archetypes: architect, ask, debug, orchestrator, scout, cartographer. Each carries its own permission cage, most deny-by-default with only what the role needs re-granted. A subagent's reach comes from its own definition, never inherited from whoever called it, and delegation depth is capped so it cannot spiral.

Every feature, one screen at a time.

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

VS Code First

If you're into TUIs or Electron wrappers, it's not for you.

Private & Local

No ads, no telemetry, no trying to sell you a service.

As simple as you need it as complex as you want it

Open a chat and get building — but within the UI you have deep analytics and levers to make it yours.

Features

01

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.

02

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.

03

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.

04

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.

05

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.

06

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.

07

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.

08

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.

09

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.

10

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

11

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.

12

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.

13

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.

14

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.

15

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.

16

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.

17

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.

18

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.

19

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.

Getting started

  1. Install Origami Coder 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.

Plan, edit, run on a model you host.

01 · Get started

Download & point at your model

Grab LM Studio (or any OpenAI-style local server: llama.cpp, Ollama), load a model, flip on the local server, and paste the endpoint into Origami. Four steps, no keys, no account.

02 · Two surfaces

Just start talking to it

Open it where you work: VS Code is the priority, and Desktop follows. Ask in plain English. It plans, edits, runs and shows the diff.

Under the hood

Workflow, built in

Run Origami out of a dedicated folder: desktop, Downloads, wherever suits. With your model connected, run /firstfold and it scaffolds the whole workspace for you: a projects folder, skills, crons and a wiki. A solid base to work from, and the structure that keeps a model's work organised instead of scattered.

1 GPU it runs on ∞ Tokens, no meter

Many agents. One board. Your machine.

Origami Coder runs agents in parallel. Each agent gets its own git worktree, its own card on the board, and its own line in the cost ledger.

01 · The Folds board

A card per ticket, seven columns, many repos

Tickets move left to right as the work moves. Start one agent, or start every queued agent in the repo at once. Register any repo on disk and drive them all from one window.

  1. TriageRaw ideas. Spec them before launch.
  2. TodoSpec'd with acceptance. Ready to launch.
  3. PendingWorktree ready, task not started.
  4. In progressAn agent is working in its worktree.
  5. BlockedNeeds you: a question or a failed run.
  6. DoneFinished, not applied to main yet.
  7. MergedApplied to main. Retired.

02 · Isolation

Every agent gets its own worktree

Start an agent on a ticket and it works in a git worktree under .origami/worktrees/, on a branch of its own. The path is excluded from git, so your working tree does not move while agents run. You can also send one task to up to four agent-and-model pairs at once, then compare the diffs and keep the best.

03 · Collab

One objective, a room of specialists

A collab is a shared room. You set the objective, the roster and the lead. You address an agent with @; the agents route work to each other with tools. ask returns an answer to the asker. handoff gives the work away for good. Each agent keeps its own session, and the room shows the open tasks, the hop budget left and the cost per agent.

04 · Extend it

Skills, MCP servers, plugins

Teach it a procedure with a skill folder. Give it more tools with an MCP server. Change the engine itself with a plugin. Give subagents their own model, with a fallback list for when a server is down. All of it is configuration in your own workspace.

05 · One window, many views

The board is one view of several

A rail down the left of the same window changes the view. The skills, the tools and the plugins each get a view here. So do these four.

  • Repo mapAn agent reads the repo and writes its map. The map opens as a tab: the parts in five columns, with the key files, the flows and the conventions beside them.
  • LabyrinthOpen a past run as a map of its steps, in one of three layouts. Select a step to read what it did.
  • InsightsEvery file that feeds the system prompt, largest first, with its size. Select a row to open the file.
  • Crons and loopsA cron registers a scheduled task with the operating system, so the run starts with VS Code closed. A loop repeats a prompt on an interval while the chat is open.

Found a bug? Want a feature? Tell us.

Send Origami Labs an idea, a bug report, or a message about Origami Coder. We read every one. Nothing leaves this page until you send it.

Compose email ↗
Goes straight to Origami Labs. Nothing leaves this page until you send.

Tip

Tell us where it fits

Name the surface — VS Code or Desktop — and the model you connected. That helps us place the idea right.

  1. You send itAn idea, a bug, or a question about Origami Coder.
  2. We read itEvery message reaches Origami Labs directly.
  3. It shapes the buildBugs get fixed. Ideas can land in a future release.