Plan
visually.
Build
agentically.
Bring your
own AI.
You lay out your app as a node graph — Plan, Architecture, Spec, Dev Stack — where every step grounds the next. Then the agent you choose makes it real: Claude Code, OpenAI, Anthropic, or a local model. You hold the plan; the AI does the building — and you watch every diff.
Your app, planned as a graph — not a chat
log.
The Flow tab is a graph you build, node by node. You lay out how the app fits together — Plan feeds Architecture, which feeds Dev Stack, Frontend, Spec, and Preflight — and every downstream node is grounded in what came before, not in whatever you last typed. Tweak a node and everything below re-derives, non-destructively. You decide the shape; the agent fills it in.
Each node reads its upstream nodes. Architecture knows your Plan; Spec knows your Architecture. The agent never has to reconstruct intent from a scroll of chat.
Tweak, switch, or A/B any node. Nothing overwrites — downstream nodes re-derive on demand, so exploring an alternative never costs you the plan you had.
Accept freezes the plan on the Out node and hands the aggregated markdown to a build session — Claude Code, or whichever model you've wired up.
Claude Code, OpenAI, Anthropic — or a local runtime if you don't want inference happening in anyone's cloud. The vault and the graph behave the same either way.
You're building with AI. Your keys are one prompt away from the model.
Every AI editor and cloud IDE treats secrets like source code. Your .env is just text on disk — and the moment you say "read the codebase and fix this," you've handed the agent every key inside it.
Fine for test keys. A liability the moment a real payment processor, a customer warehouse, or a production auth provider is on the other end.
Keys and .env, used but never exposed.
Credentials live in the OS keychain — Windows Credential Manager, macOS Keychain, Linux Secret Service — not in files the agent can read. Marline injects them into your build and dev processes; the agent only ever sees a manifest of which credentials your project needs and which are set. Never the values.
.env.local, .env.example, and .env.production.template are built from the vault at build time — gitignored by default, never sitting on disk waiting to leak.
Values flow into the process environment your dev server and build see — and stop there. They're never placed in the model's context window, no matter which provider you're routing through.
One check before you build.
Preflight walks the whole plan and confirms you're set up for success: every required credential present, env files generated, nodes accepted, dev stack resolved. If something's missing it tells you exactly what — before the agent burns a single token.
Preflight cross-checks the manifest every node produced against what's actually in the vault, so a missing key surfaces here — not three minutes into a build.
Each gap comes with the exact place to resolve it — the Vault row to fill, the node to accept — so you're never guessing what "not ready" means.
A real terminal. No JavaScript in the middle.
Marline's terminal is xterm.js on the surface and ConPTY on Windows / POSIX PTYs on macOS and Linux underneath — the same combination VS Code uses, wired directly from Rust. It's fast and lightweight, runs your real pnpm dev, and every edit the agent makes lands as a reviewable git diff.
xterm.js + ConPTY / POSIX PTYs, driven directly by the Rust core — no Node.js process sitting between your shell and the screen. Low latency, small footprint.
When your dev server prints a URL, Marline dedupes it and pops a clickable pill in the chat panel.
Token counts and per-turn cost on every assistant message. Claude Code reports it directly; others estimate from published rates.
And it's beautiful to use.
Marline is a native app that respects your attention. A quiet dark palette, considered typography, thin borders, and motion used with restraint — every surface is built to get out of the way so the work stays in focus.
A restrained near-black palette, thin 1px borders, and generous whitespace. One mint accent, used only where it means something.
Inter for the interface, JetBrains Mono for code, credentials, and paths — so structure is legible before you've read a word.
Subtle status pulses and marching-ants wires signal live state — nothing bounces or spins for decoration, and it all honors reduced-motion.
Real window chrome and a single-digit-MB installer — a Tauri app that opens instantly and feels like it belongs on your desktop.
You have an idea and a Notion doc full of thoughts. Marline turns them into a working app — visual planning first, then an agent builds it while you watch every diff. You'll touch code, but you're never asked to chmod +x anything to feel safe.
You want an IDE that treats credentials like credentials, not like source code. Get everything Claude Code gives you — plus the vault, the visual planner, and a real workspace with split panes, a terminal, and inline diffs.
We built Marline because we wanted a place to plan that isn't a chat box — and an IDE that treats secrets as a default, not an add-on.
Jordan Wright & Eric Liss · CTRL Colab
Plan it as a graph. Build it with any AI.
Download Marline, plan your app visually, and keep your credentials where the model can't read them.