Every agent. Every machine.
One command center.
Run Claude Code, Codex, Gemini, and 35+ more across every machine you own — watched, steered, and approved from one end-to-end encrypted screen.
You already run a fleet.
You just can't see it.
Claude Code in one terminal. Codex in another — that one on a box you SSH into to check. VS Code with files changing under it, and a chat app you paste code into because it can't see your repo. Four windows, zero shared state. The agent that finished an hour ago has been idle ever since. The one that needed an approval has been blocked since lunch. Nothing told you.
The IDE was built for a human typing into one machine. The ADE is built for a human directing agents across all of them.
Many sessions on screen.
Arranged like you mean it.
Tile sessions, terminals, editors, git worktrees, and assistants in a recursive split mosaic. Every tile carries a host, so one layout can reach across every machine you own.
- Save named layouts, group them, pop a group out into its own OS window
- Drag tiles between splits with edge-aware drop targeting
- Same surface in the web portal — your cockpit follows your browser
Live agent runs
you can steer.
Watch every prompt, response, and tool call as it streams — from any device. Approve permissions inline and the run continues.
- End-to-end encrypted event stream — drop offline and gap-fill catches you up
- Inline permission approvals, with the diff
- Resume the same session id from desktop, portal, or phone
Type here.
It runs there.
Open a live terminal, editor, or git view on any machine you own, from any other. Keystrokes, file writes, and commit messages are AES-256-GCM encrypted before they leave your device.
- A headless daemon —
glueprint run— turns any Linux server, homelab box, or container into a first-class host - Managed by systemd or launchd, with a local health endpoint
- Drop offline for a minute and the protocol backfills exactly the events you missed
A crew that's still there
in the morning.
Assistants keep a persona, a constitution, and a workspace on disk, with memory that survives restarts. Routines wake them on cron — nightly triage, standup prep — and if there's nothing to do, they go back to sleep without burning tokens.
- Every fact they learn lands as a typed markdown file in a local git repo — inspectable, diffable, revertible
- Daily journals plus long-term memory with an auto-rebuilt index
- Claude Code sessions resume across restarts — context carries over for weeks
Routines run the night shift.
Governance keeps it boring.
Autonomy without guardrails is a pager incident. Glueprint enforces permission tiers, tool filters, token budgets, and quiet hours in the engine — per assistant, per team, per org.
- Allow / Ask / Deny tiers layered org → host → team → assistant
- Constitutions are files on disk — versioned, reviewable, diffable
- Task flows are role-gated state machines, so an agent can't merge what a lead hasn't reviewed
- Every action lands in the audit log
The IDE didn't disappear.
It moved inside.
A real editor lives in the cockpit — review and fix agent output without alt-tabbing. Monaco panes with full LSP: diagnostics, go-to-definition, rename, code actions, format-on-save.
- Node.js debugger wired end-to-end — breakpoints, call stack, stepping,
launch.json - Task runner with problem matchers, straight from
tasks.json - Full git suite: worktrees, 3-panel merge conflict resolver, commit graph with checkout, cherry-pick, revert
The blocked agent
finds you.
Permission requests land on your phone with the actual diff — red lines out, green lines in. Allow, deny, or always-allow, and the session on your desk resumes.
- Decryption happens on-device — the relay never sees the file
- Watch live session streams from the train
- iOS and Android, same encrypted protocol as desktop
Everything around the agents,
already built.
Terminals
Native PTYs on every host — desktop and headless daemon alike. Full ANSI, tab splits, scrollback.
Git
Every agent in its own worktree. Branch management, 3-pane conflict resolver, live commit graph.
Tasks
Boards, queues, and swimlanes shared by humans, teams, and assistants — transitions gated by your task flows.
Workflows
Chain agents into pipelines with role-gated transitions, retry loops, and a play button. One workflow, many agents.
Routines
Cron-driven instructions on any assistant or project — triage an inbox every 30 minutes, sweep PRs at 9am.
Assistant Teams
Assistants and humans on one team — shared channel, shared board, shared constitution, role gates.
Memory tools (MCP)
gp_remember, gp_journal, gp_recall — typed long-term memory your agents query mid-session.
SSO, SCIM, audit
SAML and OIDC login, SCIM provisioning, org governance, and audit logs on Enterprise.
Signed auto-updates
Ed25519-signed releases, checked on launch and every four hours.
We route your code.
We can't read it.
Your agents run on your machines. The relay routes sequence-numbered envelopes it cannot decrypt and stores only a wrapped key. On the free tier, nothing leaves your machine at all.
No testimonials yet.
Receipts instead.
We're early, so there's no logo wall on this page and no invented numbers. What there is: claims you can check.
Rust, not Chromium. One native binary per platform — the engine is the same crate on desktop and headless.
Zero cookies on this site. Analytics are anonymized, first-party, cookieless. Open devtools and count them.
v1.0.0
fetched from the release feed by this page.
YAML, JSONL, markdown in ~/.glueprint. No export button needed — it's already your data.
AES-256-GCM · PBKDF2 600k · AES-KW. The exact key lifecycle is published. Read it →
Ed25519 signatures on every release artifact, verified before install.
Not another coding agent.
The layer that runs all of them.
Cursor and Copilot are agents — Glueprint runs agents. The honest comparison is with your current orchestration layer: a row of terminal tabs and a tmux session you forgot about.
Glueprint launches the same CLIs you already use, with your existing config and subscriptions. The terminal is the engine — this is the cockpit.
Free where it's local.
Paid where it's relayed.
The desktop app is in every plan, and Free includes status-only portal and mobile views. The full relay on paid plans adds live sessions, remote control, and headless CLI-daemon hosts. Your agents run on their own subscriptions or keys — no markup, no resold tokens. Downgrades never delete anything.
Free
- 1 host · 1 seat
- All agents, tiles, IDE, git
- Assistants with memory
- Portal & mobile: status only
- Community support
Pro
- 2 hosts included · +$8 each, up to 10
- Full cloud relay, E2E encrypted
- Phone + browser control
- 3 assistant teams
- Email support
Team
- 4 hosts · +$10 each, up to 50
- 2 seats · +$15 each, up to 10
- 10 assistant teams
- Org governance + audit logs
- Priority support
Enterprise
- 20 hosts · 10 seats included
- Unlimited hosts +$12 · seats +$20
- 50 assistant teams
- SSO / SAML + SCIM
- Dedicated support
CANCEL ANYTIME · DOWNGRADES BLOCK NEW CREATION, NEVER DELETE
Asked plainly.
Answered the same way.
Does my code go to your servers?
No. Agents run on your machines. The relay forwards AES-256-GCM-encrypted envelopes and stores a wrapped key it cannot open. On the free tier the relay carries status updates only — session content never leaves your machine.
I already run Claude Code in a terminal.
Keep running it. Glueprint spawns the same CLI with your existing config and subscription — and adds what the terminal can't: tiling across hosts, approvals on your phone, schedules, memory.
Do agents keep working when my laptop closes?
On a laptop, they sleep when it does. Put the daemon on a server, a homelab box, or a container and the answer is yes — that's the point of the relay.
What's the lock-in?
Plain files. Config and sessions are YAML and JSONL in ~/.glueprint, memory is markdown in a git repo, and your projects stay ordinary git repos. Uninstall, and your workflow is exactly as it was.
Which agents work?
Claude Code, OpenAI Codex, and Google Gemini are first-class adapters. 35+ more — Amp, Cline, goose, OpenCode, Qwen Code — connect through the Agent Client Protocol.
Do I need a team?
No. It's useful solo on day one — one host, local, free. Shared boards, governance, and SSO are there when you grow into them.
Why a waitlist?
Glueprint is in closed beta. Invites go out in waves, and referrals move you up the list. Already hold a code? Register at portal.glueprint.ai.
What does free actually mean?
One host, one seat, forever — the full app locally, plus status-only views in the portal and on your phone. You pay when you want to watch and control your agents live from other machines.
Your fleet is already flying.
Take the seat.
Request early access and we'll send an invite as the beta opens up. When it lands: install, point it at the agents you already run, and watch the board light up.