Skip to content
Sign inGet started
The agent controller

Privatae Host.Take control of your agents.

An always-on machine of your own that runs the coding agents and models you already pay for. You design the build pipeline. Your Host runs it, learns what you keep, and ships the result.

Start your 7-day trialSee the pipeline

Plans from $10 a month. Your agents run on your own subscriptions.

United States customers only, for now.

The Host desktop — the app rail, the circuit-trace wallpaper, and the Host's live status bar
The same Host on a phone
YOUR ACCOUNTSYOUR HOSTYOUR MACHINE
Your own accountsAny model, any agentIt learns what you keepNever billed for tokens

Two minutes fifty

What is Privatae?

A bridge network between the machines you own and the frontier models you pay for, with your Host in the middle. How people work together without sharing an account, why it is built as a DMZ, and why the code lives on a git server of our own.

Read the postThe How it works series

The build pipeline

A build pipeline you design. Any model, any agent, every step.

Building on your Host starts as a conversation, becomes a plan, and runs as steps. You decide which coding agent and which model takes each step, in a protocol file you can edit. Change the protocol and the pipeline changes with it.

Your codebase is indexed on your own machine, so every coder starts from your real code. Your Host hands each coder only the context it should have, so it builds what the plan says and nothing else.

What you keep is logged. Pick a run, adopt a file, say what you liked or what you never want again, and the Host folds that into a preference profile that shapes the next round. Over time the pipeline builds the way you would.

Work arrives as a pull request on your own git server, with your keys never leaving the vault. When the project is done, one click ships it as an app on your machine.

  • Any model, any agent, per step
    A protocol file names which engine and model take which step. Edit it and the pipeline changes.
  • Your codebase, indexed at home
    Search over your own code runs on your machine. The code and the vectors never leave it.
  • Controlled context
    The Host is the only thing that writes context to a coder. A coder gets the plan and its workspace, not the run of your machine.
  • It learns what you keep
    Picks, adopted files, and what you said in plain words become a preference profile. A "never use that" is enforced before a pod wakes.
  • Sealed keys, private git
    Credentials seal into your vault and are used through a broker. Code lives on a git server with no anonymous reads.
  • One-click ship
    A finished project ships as a signed app on your machine with one click. Merging is your click too; the Host never merges for you.

Bake-offs

Many versions at once, built off the real thing.

For UI work, send one task to several agents at once. Each builds in its own pod against a copy of your real project, not a stub, so what you see is what would ship.

The previews sit side by side. Pick the one you want, and adopt copies it into the project as it is, with no model in between and an undo if you change your mind. The pick is recorded, so the next round starts from what you chose.

  • Your own subscriptions
    Each agent signs in with the account or key you already pay for. Your rate limits, your spend, nothing marked up.
  • Judged by you
    You pick. A model never grades another model's work.
  • Adopt copies, never rebuilds
    The version you chose goes into the project byte for byte. Nothing is regenerated on the way in.
  • Nothing left behind
    When a run ends its pod is destroyed. What survives is the branch and your pick.

The roster

The agents you already use, each in its own sandbox.

Each one is the vendor's own binary, signed in the vendor's standard way with the account or key you already have. It runs in a disposable pod on your machine's side of the line: its own user, its own workspace, only the credential it needs, and an internet exit that is logged for you. We comply with each provider's terms of service and never build a login of our own. If a provider's terms don't allow a use, we don't offer it.

  • Claude Agent SDK
    Anthropic
    Your own Anthropic account.
  • Codex
    OpenAI
    Your own OpenAI account.
  • Cursor
    Cursor
    Your Cursor API key.
  • Grok
    xAI
    Your own xAI account.
  • Kimi Code
    Moonshot AI
    Your Kimi or Moonshot key.
  • opencode
    Open source
    Your OpenRouter key — any model it lists.
  • VS Code
    Open-source build
    A full editor in your browser. Its workspace persists between sessions.

Names and marks belong to their owners. A tool on this list means your Host can run it in a sandbox on your machine — not that its maker endorses us.

The controller

One Host in charge of all of them.

Your Host is the controller. It holds your accounts, hands each agent one task, grants only what that task needs, and takes the grant back when the task ends. The agents never hold your keys, and the agents you talk to cannot run code at all. Code runs in throwaway pods, and only there.

Every run is on screen: status, output, cost. Every one of them ends the moment you say so.

How that is enforced
  • Nothing at dispatch
    An agent starts with no capabilities. The Host grants what the task needs, per task, and the grant ends with it.
  • Keys stay with the Host
    Agents use your credentials through a broker. They get results, never the bytes.
  • Code runs elsewhere
    Conversation and code are separate lanes. Code goes to a disposable pod that is gone when the run is.
  • A kill switch on every run
    The live view shows every run. Any of them stops when you stop it.

The machine

A machine of your own, always on.

Every account gets its own machine: its own database, its own filesystem, its own hostname, its own identity. It keeps working when you close the tab. Open it from a laptop or a phone and it is the same machine, mid-task, where you left it.

  • Yours, not a row in ours
    Your data lives in a database you hold on a machine that is yours. Cancel, and it is kept for 90 days in case you come back.
  • No inbound ports
    The machine dials out to one gateway. There is no port to scan, on it or on the machines you join to it.
  • Sleeps when idle
    An idle machine hibernates on its own and wakes on traffic. Sleeping costs nothing.
  • A desktop, if you want one
    A windowed desktop in any browser, phone included. The machine runs with or without it.

The network

Your hardware joins. Your Host reaches it.

One curl line installs the bastion on a Mac, Linux, or Windows machine: a single static binary, no root, no kernel module. From then on that machine and your Host share one private network. A GPU under your desk, a server in your office, a laptop on the road: your Host can use them, and nothing else can.

Your Host's internet traffic can leave through your own connection, under your own address. And managing the bastion is a fixed list of operations, never a free-form shell.

Episode 3 — The network you own
Read it, and watch the series
  • One curl line
    A static binary, userspace WireGuard, no root. Installed in a minute, removable without a trace.
  • Scoped to your Host
    The tunnel reaches your Host and nothing else's. The key that opens it opens nothing else.
  • Your egress
    Outbound traffic can leave through your home connection. What your Host does on the internet uses your address, not ours.
  • An allowlist, not a shell
    The bastion answers a fixed set of operations with fixed arguments. Everything else is refused.

Models

Any model you pay for. Any model you run.

Your OpenRouter key and direct provider keys slot in. Models running on your own hardware join over your private network. A subscription you already pay for is used only where that provider's own tool allows it, signed in the vendor's standard way, inside the sandbox that runs it. We comply with each provider's terms of service, and we never build a login of our own.

Route each job to a different source if you like: chat, code, review, planning, research, embeddings. Per-model prices are shown in the product, so the choice is an informed one.

  • Your API keys
    OpenRouter plus direct providers. Keys seal into your vault; the Host uses them through a broker and never sees the bytes.
  • Your subscriptions
    Used only through the vendor's own tools and standard sign-in, under the vendor's terms. We are never in that billing path.
  • Your own hardware
    Models on your machines, reached over your private network. The request never crosses our side at all.
  • One lane per job
    Chat, code, review, plan, research, embeddings. Each gets its own source, changeable whenever.

Billing

Never billed for tokens.

The subscription buys the machine. Inference and embeddings are never billed, because they run on your keys, your subscriptions, and your endpoints, under each provider's own terms. There is no token meter in the code to mark up, and a tripwire that runs against production goes permanently red if a token charge ever lands.

The only meter is borrowed machine time. Extra machines your Host pulls on demand, such as build sandboxes and editor sessions, come with a set number of hours in every plan. Past that they meter per second at $0.05 per vCPU-hour and go on your monthly bill. Your own machine never meters.

Pricing, in full
  • No token meter exists
    There is no token billing path in the code. A tripwire checks that continuously.
  • One monthly bill
    Nothing to top up and no balance to run dry. Usage past your plan is billed at renewal, and nothing else ever is.
  • Cancel and get the rest back
    Cancel and the unused time goes back to your card automatically, pro-rated to the cent.
  • Idle costs nothing
    A sleeping machine doesn't touch the bill.

The Host

Memory that outlives any one model.

Your Host is a named resident of your machine, not a session. Its memory persists across restarts, models, and providers, so you can swap the model underneath and it is still your Host. The model companies see the request you send. Your Host holds the rest.

Episode 1 — What a Host is
Read it, and watch the series
  • Memory that corrects itself
    Correct it once and the old version is retired, not deleted, with the lineage kept. Ask what it believed last Tuesday and it can tell you.
  • A memory can be hidden from a model
    Scope a memory away from a specific model or vendor. The scope is enforced when memory is fetched, not requested in a prompt.
  • Recall on your own hardware
    The embeddings behind recall can run on your own GPU over your own network. The text never leaves your hands.
  • A personality you can tune
    Ten weighted dimensions, set by sliders. It proposes changes; you approve them.

Community

Built with its members.

The platform is community-developed. What members ask for is what gets built — and the asking happens privately, from inside the product, never in a public issue tracker.

  • A place to learn
    A built-in, members-only community. People who run their own machine, comparing notes.
  • Members-only git
    git.privatae.ai hosts members' code with no anonymous reads. No scrapers, no training on your work.
  • Proposals that ship
    Feedback and feature proposals flow in privately from inside the product. The ones with traction get built.
How the community worksgit.privatae.ai

Beyond one machine

Building a business on it? Want it on your own hardware?

Host is the machine. Ceigas is what you build a business on it with: sites, paywalls, and billing that settle to your own accounts, with your customers in your own tables. And the controller is licensed for hardware you bring, rented anywhere or owned, so a team can run it where its data already lives.

ceigas.aiThe license, on the pricing page

Take control of your agents.

Start your 7-day trial

From $10 a month. Cancel any time and the unused time refunds automatically.

United States customers only, for now.

Privatae Host — Take control of your agents