Zealve
Zealve Forge · Product 04

One cockpit for all your AI agents

Forge is a local-first desktop app that runs many AI coding agents in parallel — ACP-first, with a built-in DeepSeek harness, sessions that freeze instead of dying, budgets with a hard stop, and a plugin law that makes every subsystem swappable at runtime. A pure Rust core. No cloud in the way — and free while the open alpha runs, with pricing shaped later by the people who use it.

Alpha — free while testingACP-first — any agent plugs inDeepSeek & local models built inFreeze — cold sessions, never lostBudgets with a hard stop
Forge on the record: <b>ACP-first</b> — any agent plugs in natively · DeepSeek + local vLLM / Ollama first-class · Freeze — park an agent, wake on prompt · Budgets with a hard stop · Rust core · <b>Open alpha</b> — free while testing
01 — Why it exists

The agent boom got fragmented. Forge is the cockpit.

A working developer now runs three to five AI coding agents a day — a frontier model in the cloud, DeepSeek on a budget, a local model on the laptop, a specialist agent for reviews. Every one of them ships as its own island: its own terminal, its own session store, its own idea of status. The category's shared ceiling is transport — tools scrape terminal output and hook events instead of speaking a protocol, so status gets guessed from silence and sessions die with the window.

The gaps are specific and unclaimed. No tool uses ACP — the Agent Client Protocol — as its primary transport. No tool ships DeepSeek or local-endpoint support natively, even as local model servers became the default for cost-sensitive teams. The popular fleet managers are slow and put basic features — automations, org views — behind subscriptions. And the deepest problem is structural: the tools that delegate work to agents can't reach the code, and the tools that own the code have only a thin notion of delegation. Nobody ships both halves. That junction is exactly where Forge sits.

  • No tool speaks ACP as primary transport — everyone scrapes terminals and hooks
  • No native DeepSeek or local-endpoint harness anywhere in the category
  • Automations and org features gated behind subscriptions as paywall bait
  • Delegation tools can't touch the code; code tools can't delegate
  • Heavy app shells for what is fundamentally a fleet of subprocesses

Sources: forge research corpus (2026-09) — deep dives read from the real source of six reference tools; feature matrix with adopt/reject decisions; internal dogfooding ledgers.

What it is

A fleet console that never lies to you.

Fleet shows every session, on every host, in one view — working, waiting on your approval, or cold. The board turns tasks into agent assignees with real worktrees and execution logs you can replay. When an agent needs a decision, it asks with context; approval is one act, recorded. Freeze parks a running agent with its transcript and mode intact — cold is never misfiled as terminated, and the next prompt wakes it. Status is never guessed from silence, and the run record counts durable evidence instead of prose.

  • Fleet — all sessions, all hosts, one honest view
  • Board — kanban with agent assignees + execution logs
  • Diff review — inline comments ship back to the agent
  • Fan-out — one prompt, N attempts, one merge you choose
  • Budgets with hard stop — per session, per agent, per team
  • Git graph + PR flow — branch, push, open PR from the app
Join the engineering cohort →
03 — How we build it

ACP as the spine. Rust as the ceiling. Plugins as the law.

Forge's daemon is pure Rust: it owns the sessions as subprocesses, stores everything in SQLite and JSONL transcripts on your disk, and serves one API that the desktop shell, the CLI and your phone all speak as peers. Agents connect over ACP — the protocol is the transport, not a scraper — and the built-in DeepSeek harness doubles as a client for any OpenAI-compatible endpoint, so a local model server is a first-class citizen. The plugin law applies to everything, including our own features: every subsystem sits behind a registry, plugins are processes speaking the same framing, and enable or disable happens at runtime with no restart.

The product is held to honesty laws the same way Zealve's other platforms are: status is never guessed from silence; cold is not terminated; a run cannot promote its own output; every control states its real limitation instead of faking it. The design follows the same Onyx language as the rest of Zealve — a near-black instrument panel where machine facts are monospace and human voice is the UI sans — because a fleet of agents should feel like a cockpit, not a slot machine.

  • ACP-first runtime — adapters are data, not code
  • Built-in DeepSeek harness — DeepSeek, vLLM, Ollama, any compatible endpoint
  • Pure Rust daemon — SQLite + JSONL transcripts, local-first, works offline
  • Plugin law — every subsystem registry-swappable, hot load/unload
  • Freeze/wake — budget-aware eviction, wake-on-prompt, restart-proof
  • Forge Mate (research) — a coordinator agent delegating to workers across desktop + VPS, where every abstract view descends to the real worktree, diff and terminal
Who it's for

Built for people who run agents like staff.

AI-native developers

3–5 agents open before lunch

You already parallelize: one agent on the ticket, one on review, one exploring. Forge gives that fleet one cockpit — shared budgets, honest states, and a board where assigning a task creates a real worktree instead of a hope.

Small teams & studios

Your own agents, your own hardware.

VPS hosts join the fleet as peers with capacity and dispatch rules — your fleet runs on machines you pay for directly, not on someone else's margin.

Cost-sensitive builders

DeepSeek and local models, first-class.

The built-in harness treats budget models as equals, with per-session token and cost accounting — so the cheap model gets the same cockpit the expensive one does.

Privacy-minded engineers

Local-first, no accounts.

Sessions, transcripts and usage live in SQLite on your disk. No cloud dependency, no telemetry requirement, works offline — tunnels and remote hosts are opt-in.

Early cohort

Dogfood it with us.

Forge builds Zealve's products every day — the early cohort gets builds at the same cadence we use internally, and a direct line to the roadmap.

Who it serves

One Forge, three consoles.

The same product ships three views — regular, experimental and advanced — because the person handing an agent a task and the person operating a fleet of ten are often different people, sometimes on the same team.

Founders, operators and first-timers

One agent. One prompt box. Honest status.

You don't manage agents — you hand over work. Ask in plain language, watch it do the job, approve when it asks. Nothing to configure, no jargon to learn, and when you close the laptop the work isn't gone: freeze keeps the session intact until you're back.

Beyond software teams: solo founders clear busywork, students ship course projects, clinic and agency admins connect their tools — the regular view keeps the cockpit out of the way.

  • A plain-language prompt box — no harness picker, no flags
  • Status in words: working, waiting on you, cold — never a cryptic state
  • Approvals are one tap, with the blast radius spelled out first
  • Local-first: works on your machine, offline, no account
Alpha · free while testing

What is a fleet worth to you?

Alpha · agent fleet ROI
3 coding agents working in parallel
6 h / agent / week (conservative for ticket + review work)
AED 150 / h
AED 1,500 / month — DeepSeek and local models count less
ENGINEERING VALUE PER YEAR
AED 140,400
Hours returned per year936 h
That time, at loaded costAED 140,400
Model + API spend per year−AED 18,000
Forge alpha (free while testing)AED 0
Net in year oneAED 122,400

Model: agents return focused engineering hours — tickets, tests, reviews, migrations — and your fleet runs on hardware you already pay for.

FAQ

Straight answers.

Does Forge replace my editor or my terminal?

No — it sits above them. Forge owns the agent sessions and the worktrees; the editor pane and raw terminal views are for when you want your hands on the same code the agents are touching. Your editor stays yours.

What happens to a session when my laptop sleeps?

The daemon owns sessions as subprocesses and discovers them from disk, so restarts and sleep don't lose work. Freeze parks an agent deliberately — transcript and mode survive, and the next prompt wakes it. Cold is a state, never a euphemism for dead.

Why ACP instead of scraping terminals?

Because guessed status is how work gets silently broken. ACP gives structured session state, permission requests and resumable transcripts — so "waiting for approval" is a fact the agent asserted, not a pattern someone matched in a scrollback buffer.

What will Forge cost after the alpha?

No pricing exists yet — on purpose. The alpha is how we learn which features matter before we attach numbers to anything. The plan: the local-first core — sessions, board, budgets, automations, plugins — stays free with no accounts, and advanced and experimental modules (premium harnesses, managed fleet services, team sync, priority support) ship as optional paid services on top. Alpha cohort members lock in founding-member terms when pricing lands.

The Forge alpha

Free while we test. Priced later, together.

Forge is not a free tool and it is not a paid product yet — it is an alpha. We release builds in waves, watch what fleets actually do, and let real usage — not a spreadsheet — decide what the paid layer looks like.

Inside the alpha

Now — free
everything that exists today
  • Fleet, board, diff review, fan-out
  • Freeze/wake, budgets with hard stop
  • DeepSeek + vLLM/Ollama harnesses
  • Local automations & the plugin law
  • Direct line to the roadmap

After the alpha

the core stays free
  • Core runtime free — no accounts required
  • Advanced & experimental modules become optional paid services on top
  • Premium harnesses, managed fleet runs, team sync
  • Priority support & onboarding services

Pricing

TBD
deliberately not decided yet
  • No pricing module exists today
  • The alpha cohort shapes what gets charged
  • Founding-member terms locked for early members
  • Published here first, in plain numbers
Forge · open alpha

Get an alpha build. Shape what ships.

The alpha opens in waves — AI-native developers and small teams running multiple agents first, worldwide. Tell us what you build with; we'll match you to a build and the roadmap discussion. Alpha members keep founding-member terms when pricing exists.

Phone or IM number / What would you use it for? · optional
Interested in

We reply personally. No spam, ever.

Forge — every coding agent, one cockpit, your machines — Zealve