The mesh

Not one model. A mesh of them, on the same problem.

meshcode's whole point is in the name: instead of one expensive model doing everything, you connect several and let them work together — running side by side on separate projects, and handing each other the parts they're each best at. Here's what you can put in the mesh, and how you wire it.

Two ways models work together

The mesh runs in both directions at once. That's the difference between a model picker and an orchestration layer.

view_column

Across — several models, side by side

Each pane runs its own model on its own project, all at the same time. Four panes, four models, four things moving. Switching one doesn't cost you the context in any of the others — which is exactly why people give up on moving cheap work to a cheap model elsewhere.

call_split

Down — one model hands work to the others

The model in a pane doesn't have to do the boring half itself. It delegates bulk file reads, wide searches and boilerplate to cheaper models running underneath it, and gets back a summary instead of forty files. Its context — and your quota — stays on the part that actually needed it.

What you can put in the mesh

Two billing axes, not one: mesh draws from a prepaid balance you top up, and everything else runs on a subscription you already hold, billed by that provider — meshcode never rebills it. Mixing both in one mesh is the normal setup.

bolt

mesh

account_balance_wallet Metered from your prepaid balance

Built in. Nothing to install, nothing to connect — it's there the moment you sign in, and it's what the mesh falls back on when you haven't brought anything else.

  • Flow
    Fast, lightweight tasks. Answers immediately, without a thinking pass.
    mesh:flow
  • Logic
    Multi-step reasoning. Thinking mode.
    mesh:logic
  • Architect
    Complex design and refactors. Thinking mode, longest leash.
    mesh:architect

Flow, Logic and Architect are the only model choice meshcode asks you to make. Live per-tier pricing and context length are in the app under Account → Models.

terminal

Claude

link Your own Anthropic subscription — not rebilled

Drives the Claude Code CLI you already have installed — your skills, hooks, MCP servers and CLAUDE.md carry over untouched.

  • Haiku
    Bulk file reads, wide searches, boilerplate.
    claude:haiku
  • Sonnet
    Heavier subtasks that still aren't the core problem.
    claude:sonnet
  • Opus
    Judgment, design, final synthesis.
    claude:opus
  • Fable
    Available in the mesh alongside the rest.
    claude:fable
terminal

Codex

link Your own ChatGPT subscription — billed by OpenAI

Drives the OpenAI Codex CLI on your machine, one process per turn.

  • gpt-5.6-luna
    Lighter Codex turns.
    codex:gpt-5.6-luna
  • gpt-5.6-terra
    Heavier Codex turns.
    codex:gpt-5.6-terra
terminal

Grok

link Your own xAI subscription — billed by xAI

xAI's Grok CLI, sitting next to Codex in the top bar.

  • grok-4.5
    General coding turns.
    grok:grok-4.5
  • grok-4.6
    General coding turns, newer.
    grok:grok-4.6

Off by default — turn it on in Settings → Models.

hub

OpenRouter

link Your own OpenRouter credit — billed by OpenRouter

Your key, your model id, your provider routing. Whatever OpenRouter serves, the mesh can use.

  • OpenRouter
    You set the model id in settings; meshcode passes it straight through.
    openrouter

Because the model is yours to choose, meshcode makes no assumption about what this slot is good at — see “Who decides which one is better” below.

dns

Local / custom endpoint

lock_open Free — the app talks to it directly, bypassing our gateway

Any OpenAI-compatible URL — a model on your own machine, or anything you already host.

  • Your endpoint
    Point it at a URL, model name and key in settings; it appears in the picker next to Flow.

Wiring the mesh

Nothing is handed to a model you didn't put in the mesh. In Settings → Delegation you tick who's allowed to receive work, and in what order they're tried. These are the keys that appear:

Delegation keys

claude:haikumesh:flowopenroutermesh:logicclaude:sonnetmesh:architectcodex:gpt-5.6-lunaclaude:opuscodex:gpt-5.6-terragrok:grok-4.5grok:grok-4.6claude:fable
  1. 01
    Tick who's in
    Nothing is delegated to a model you haven't checked. Tick a whole provider to bring all of its models in at once.
  2. 02
    Drag them into the order you want tried
    The list order is the priority. Put the cheap worker you trust for bulk reads at the top.
  3. 03
    Optionally, close the mesh to exactly that list
    With the restrict toggle on, the orchestrator can't reach for anything outside what you ticked — useful when a provider's quota is the thing you're protecting.

Who decides which one is better

Not us. The list above is a stable catalog, not a leaderboard — meshcode deliberately ships no capability ranking for these models, because one coarse ordering is wrong for most real work. Two things decide instead:

  • drag_indicator Your order. The priority you drag in the Delegation panel is followed as given.
  • history Its own track record. The orchestrating model keeps a delegation history in the project and reads it before handing off, so what actually worked on your codebase outranks any generic ranking.

The rule that holds up in practice: delegate what you can verify — a build, a test or a diff checks it. Keep judgment, design and anything subtle on your top model.

Looking for exact prices and context lengths?

They change as the catalog changes, so they live in the app rather than on this page. Account → Models lists every routable model with its live per-million-token price, context length and whether it accepts images.

Open the live catalog in the app →
Sign up See how billing works →