Getting started

You sign in to the Cadrix Cloud dashboard (Sign in at the top of this site) with a magic link (no password to remember), pick a plan and pay. The panel then creates your server, starts it, installs Cadrix and issues a TLS certificate for your-address.cadrix.app. It usually takes about four minutes; you can close the page and come back.

When the status says Ready, click Open Cadrix. The panel shows your Cadrix password once: store it in a password manager, because the control plane deletes its copy as soon as you close the dialog. If you lose it, write to [email protected].

• One VM per subscription. Everything below runs on that machine: the canvas, the agents, your repositories and any app you run.
• Your address is your-address.cadrix.app. Open it from any browser, including your phone, and install it as an app.
• Region: Germany (Nuremberg or Falkenstein) or Finland (Helsinki), whichever has capacity when your VM is created.

The canvas

A workspace is a directory on your VM (usually a repository) and a canvas for it. The sidebar on the left lists workspaces; the toolbar at the top adds items to the canvas; the controls at the bottom right zoom and fit.

200 OK · 23 ms · application/json
[{ "id": 1042, "total": 2800, "status": "paid" }, …]

Three kinds of items live on the canvas:

• Agents: a Claude Code, Codex or Pi session, shown as a terminal or as a chat.
• Notes and binders: Markdown files pinned to the canvas, optionally grouped in a binder with pages.
• Browser portals: a real Chromium that agents can drive and you can watch.

Cables are permissions. An agent can only talk to the agents, notes and browsers it is connected to. Draw a cable to grant access; delete it to revoke. There is no other access list to maintain.

The toolbar offers, left to right: select, add agent, add browser, add note, add binder, auto-arrange (with undo), focus mode, multi-workspace and delete. Items can be dragged, resized and connected by dragging from the blue handle on their edge.

Agents: terminal or chat

When you add an agent you choose the runtime (Claude Code, Codex or Pi), a display name and a role. The role is a short brief the agent receives on every start (presets such as developer-backend, reviewer or qa, or your own text). Each agent gets a private home directory on the VM and the Cadrix CLI already authenticated.

Every agent has two faces you can switch with the Chat | Terminal toggle in its title bar:

• Terminal: the official CLI running in a tmux session. It survives page reloads and keeps running while you are away; anything you could do in a terminal, the agent can do.
• Chat: a graphical transcript over the same runtime. Tool calls are shown as cards (Read, Write, Edit, Bash, browser actions), file paths are clickable and open the editor, and long tasks show a timeline.

tmux · cadrix_nd_8c6d…
› Implement the /v1/billing webhook with idempotent event ids.
• Read src/billing/webhooks.ts
• Edit src/billing/webhooks.ts (+38 −4)
• Bash pnpm test -- billing
  41 passed
› 

In chat mode the composer carries the session settings: model, effort, permissions (for example bypass permissions for unattended work), extended thinking where the runtime supports it, and a context meter showing how much of the window is used. You can attach files and images, queue a message for after the current turn, steer the agent mid-turn, stop a response, and open the Subagents panel when the agent spawns helpers. The title bar shows the status: busy, idle, starting, stopped.

The session above is scripted, but the game is real: it was written by an agent exactly this way, served from the VM and opened in a browser portal on the same canvas.

Connecting your model providers

Two ways to pay for models, chosen per runtime in the chat's settings gear under Model credentials: your own subscription or API key, whose credentials live on your VM only, encrypted at rest (the control plane never sees them), or Cadrix credits. In Automatic, the default, a runtime uses your own credential when it has one and credits otherwise, so a new VM works from the first chat without any setup.

• Claude Code: Sign in with Claude opens the sign-in page in your browser; paste the code back and the CLI is signed in. No terminal needed.
• Codex: Sign in with ChatGPT, same flow.
• Pi and any of the three also accept an API key (Anthropic, OpenAI, Google, OpenRouter and other providers Pi supports).

The chat shows a small alert on its settings gear when a runtime has no credentials yet. Provider terms are set by the providers and may change; API keys are always the fully supported path.

Agents talking to each other: the cadrix CLI

Every agent has the cadrix command on its PATH, already authenticated as that node. It is how agents delegate, share notes and drive browsers, and it only reaches the items connected to them by a cable.

$ cadrix peers
{ "peers": [ { "name": "Reviewer", "kind": "agent", "status": "idle", "agent": "codex" },
             { "name": "Plan",     "kind": "note" } ] }
$ cadrix ask "Reviewer" "Review src/billing/webhooks.ts for retries and idempotency. Reply with a list of issues." --timeout 10m
… waiting for Reviewer …
1. The Stripe event id is not stored, so a redelivered event is processed twice.
2. …
$ cadrix note append "Plan" "- [ ] store stripe event ids (Reviewer)"

Agents in chat mode get a skill that teaches them these commands, so "ask the Reviewer to check this" in plain language is enough.

Maestro teams

Maestro turns one agent into a manager. You enable it from the agent node; the manager can then recruit up to eight specialists and create up to two browser portals in the same workspace, all through the CLI, while you watch the team assemble on the canvas.

• Recruit with a role preset or a custom brief, choosing the runtime and terminal or chat mode. Each recruit is created already cabled to its manager.
• Brief and collect with the ordinary ask and tell; the manager consolidates the results.
• Notes for the team: the manager can create shared notes and connect them to recruits explicitly.
• Reassign or dismiss idle recruits; dismissal cleans up the runtime and credentials before removing the node.
• Attention: a recruit or the manager can light an indicator on the UI when a human decision is needed.

Maestro is opt-in per agent and checked server-side; an ordinary agent cannot promote itself.

Squads: ready-made teams

A squad is a team assembled for one outcome: a leader with Maestro, the specialists it needs, a shared team note and the cables between them, each agent briefed for its role and given the skills for it. Open Create an agent, switch to the Squads tab, pick a card, choose a model for each member (or the cheapest for all), write the brief, and the team appears on the canvas. The leader greets you in its chat without spending anything; you send the first message, it discusses the approach and confirms the plan with you before delegating. Tick Start right away if you would rather it plan and dispatch from the brief on its own.

• Skills are written into the workspace as .claude/skills/<name>/SKILL.md; Claude Code loads them, and every role file lists them by path so Codex and Pi read them too. Edit them: they are yours.
• Runtimes and models follow what is signed in on your Cadrix (or your credits); each member prefers Claude Code, with QA and reviewers on Codex for an independent second opinion. The model you pick per member is kept on the node, so a stopped specialist runs with it; change it any time from the agent's chat, even while it is stopped.
• The team note holds the brief, the plan and the status board; the leader keeps it current and it is what you read to follow along.
• One live agent. Only the leader runs from the start; each specialist is created stopped and wakes for the task the leader delegates, then stops. A squad fits the Starter plan.
• On Cadrix credits every agent that works spends from your balance; a small mission usually spends about US$1 to 3 (measured: the leader's coordination alone was about US$0.87 in a minute on Sonnet 5). The dialog says so when your runtimes run on credits.
• A squad is an ordinary Maestro team afterwards: reassign or dismiss recruits, add notes, enable a browser portal for QA.

Notes and binders

Notes are real Markdown files pinned to the canvas. They survive restarts, you can watch agents edit them live, and they are the natural place for plans, TODO lists and handoffs between agents.

Above, a scripted session: the agent reads the note with cadrix note read, ticks a task with note write and adds a line with note append; the note on the canvas updates as it happens.

• Edit in place with an Edit | Preview toggle, add images, pick a color.
• Binders group several pages under one item; agents read a binder as a whole.
• Agents use cadrix note append rather than write when several of them share a note, so nobody overwrites the others.

Browser portals

A browser portal is a real Chromium running on your VM, shown live inside the canvas. Agents connected to it can open URLs, take an accessibility snapshot, click, type, wait for text, screenshot and read console and network logs; you can watch and take over at any time.

Each portal is contained in its own profile and process group and shows its status in the title bar (starting, running, stopped). Plans limit how many portals run at once. Cables apply here too: a browser is only visible to the agents connected to it.

Previews and subdomains

Anything your agents run on the VM is already on the web. Every listening port gets an HTTPS address under cxapp.dev (a domain kept apart from cadrix.app on purpose), with a wildcard certificate issued and renewed for you: nothing to configure, no server to set up.

• By port: a server on port 3000 answers at https://3000.you.cxapp.dev.
• By name: link a name to a port and it becomes https://snake.you.cxapp.dev. Names use lowercase letters, digits and hyphens, start with a letter and have up to 32 characters.
• Private by default. A preview opens only for someone logged into your Cadrix; anyone else is sent to the login page. Public by choice, per port or per name, after a confirmation that shows the link; you can make it private again at any time. Public is for things meant to be seen: a demo, a link for a colleague, a webhook endpoint.
• Dev servers just work. WebSockets pass through, so hot reload works from the preview address; the Host header is rewritten, so servers that check it (Vite, Next) are happy.
• Ports used by the system and by Cadrix itself never become previews; only ports opened by your agents do.

From the interface: the Previews button in the sidebar (also in the mobile cockpit). Subdomains lists each name with its port, Private/Public and Running badges, and Open, Copy, the Private | Public switch and Remove; the form below adds a name to a port. Listening ports shows what is running right now, with the same actions plus Name it.

From an agent: the CLI has a preview command, and the agent's skill tells it to register a preview after starting a server and hand you the link. It only makes a preview public if you ask.

$ cadrix preview list
$ cadrix preview add snake 3000
{ "name": "snake", "port": 3000, "public": false,
  "url": "https://snake.you.cxapp.dev/", "listening": true }
$ cadrix preview public snake on
$ cadrix preview url snake
https://snake.you.cxapp.dev/
$ cadrix preview remove snake

Custom domains. Point a domain you own (such as app.example.com) at a port, from the same panel where you name a subdomain. Create a CNAME at your domain pointing to you.cxapp.dev (an apex domain needs an A/ALIAS record instead, at the address the panel shows), then a TXT record at _cadrix-challenge.app.example.com with the token Cadrix gives you, to prove you own it. The panel shows where things stand — waiting for DNS, DNS not pointing here yet, active, or lost if the TXT record disappears later — and a custom domain is private or public exactly like the port it serves. Up to 5 per machine.

What it is still not: a production deployment with scaling, a CDN or an uptime guarantee. It is your app running on your VM, with its own TLS certificate either way.

Code editor

Cadrix Code is the workspace editor, one click away from the canvas. It is a Monaco editor with a file explorer, quick open, and a source-control panel with diffs, discard and commit. The agents panel sits beside it, so you can review a change and answer the agent in the same view; clicking a file path in a chat opens it here.

HTTP client

A Postman-style client built into the editor: collections of requests, environments with variables, secrets kept apart from the collection, request bodies of several types and a response viewer. Import a Postman JSON, export a collection or environment.

Database client

Connect to Postgres or MySQL databases reachable from your VM and query them in a SQL book with completion. Results are paged and can be exported; connections can be imported and refreshed.

Focus mode

Focus mode turns the canvas into tmux-like panes so you can concentrate on a few items at full size. Each pane has tabs; each tab is a canvas item (agent, note, browser or binder) with its kind icon and status dot.

• Split a pane to the right or downwards, maximize one pane, close panes, drag tabs between panes.
• Open an item here lists everything on the canvas with a search box; an empty pane shows the same finder.
• Tabs show cable links: a yellow badge lists what the item is connected to.

Multi-workspace

The multi-workspace view uses the same panes as focus mode, but its tabs are items pinned from any workspace. Watch the backend agent of one project next to the notes of another. The layout is saved on the server and follows you to every device and tab.

• Open it from the toolbar or with ?view=multi in the address; it can be bookmarked.
• The picker groups items by workspace. Each tab carries a workspace chip and a go to workspace button that jumps to that item on its own canvas.

Install Cadrix as an app

The simplest way to use Cadrix on any device is to install it from your browser. It gets its own icon and window (full screen on a phone), opens straight to your Cadrix and always runs the version on your server: there is nothing to download or update. Open your address, sign in, then:

The installed app is the same Cadrix you open in a tab: same sign-in, same data. Remove it like any other app (long-press its icon on a phone, or from the app window's menu on a computer).

Mobile cockpit

Your Cadrix works in a phone browser at your address. For its own icon and a full-screen cockpit, install it as an app.

You can also pair a device from Settings → Mobile devices: create a QR code, scan it, then approve the device with its confirmation code. The device gets its own token, so you never type your password on the phone, and you can revoke it later.

The cockpit has three buttons at the bottom. It opens on Multi: every item pinned from any project, with what each agent is doing. Tap an agent to open its chat and answer it, or a note to read or edit it; Pin an item adds more.

• Canvas: a project's canvas, read-only. Pan and zoom to see agents, notes, browsers and cables; nodes cannot be moved, resized, connected or deleted from the phone. The project picker above it chooses which canvas is shown, and Enter focus mode opens one node full screen. A badge on the button counts the agents that need your attention.
• + (Create): a chat or terminal agent, a squad, a note or a browser portal in a project, or a New project.
• The All projects filter at the top narrows Multi and the canvas to one project.

Your account and plan

Plans are VM sizes. All of them include Cadrix, TLS at your address and the same features; they differ in CPU, memory, disk and how many agents and browsers run comfortably at once.

• Currency: plans are charged by card in reais for customers in Brazil, at a promotional price of R$ 79, R$ 159 and R$ 319 per month, 20% off (the regular price will be R$ 99, R$ 199 and R$ 399 when the promotion ends), and in US dollars elsewhere. Cards issued in Brazil can only be charged in reais.
• Billing is handled by Stripe; Manage billing in the panel opens the customer portal to update the card or cancel.
• Credits: the panel shows your balance and sells packs of $10, $25 and $50; see Cadrix credits.
• Changing plan: write to [email protected] and we move your VM to the new size, with a couple of minutes of downtime. Self-service changes are coming.
• Cancelling ends the subscription; when it ends, the VM and its address are deleted. Push your repositories somewhere else first.
• Updates: your VM only installs Cadrix releases signed by us and upgrades in about twenty seconds.

Support

Support runs by chat inside the app: it answers right away from this documentation and your account's own facts, and anything it can't resolve itself is registered for our team to review once you end the conversation.

• Human support hours: Monday to Friday, 9am to 5pm (Brasília time), with a first reply within 1 hour in that window. Outside it, the reply comes the next business day after 9am.
• Invoice (nota fiscal): we don't issue one by default, only on request through support. Ask in the chat, with your full name or razão social, CPF or CNPJ, billing address and e-mail ready.

Cadrix credits

Credits are a prepaid balance in US dollars that pays for model usage per token, so Claude Code and Codex work without a subscription or key of your own. Every account starts with $2; packs of $10, $25 and $50 are sold in the panel through Stripe. In Brazil a pack is charged in reais at the day's PTAX rate from the Central Bank of Brazil, with no spread; the balance stays in dollars. Credits never expire, belong to your account rather than the VM, and usage stops at zero: you are never charged beyond what you bought.

• Where you see them. The chat shows the balance next to the model picker and, when it runs out, a notice with two exits: buy credits or connect your own login.
• Cheap by default. On credits, Claude Code starts on Sonnet and Codex on the mini model; each model in the picker says how it spends credits relative to that default before you switch.
• Applies on the next start. Changing the credential mode takes effect the next time the runtime starts, not mid-conversation.

Prices per million tokens, in USD, including our margin over the providers' list prices. They change when the providers change theirs; the price at the time of each call applies.

Security and data

• Dedicated VM. Your Cadrix is not a container on a shared host. Repositories, agent credentials and data live on its disk.
• Model traffic. With your own login or key, agents call Anthropic, OpenAI and other providers directly from the VM; we never read your tokens. On credits, calls go through our model gateway, which records usage metadata (model, tokens, cost, time) for billing and never stores prompts or responses.
• Agents have real shells on your VM by design. Cables limit what they can reach inside Cadrix; the VM boundary limits everything else.
• Data plane on loopback. The CLI agents use talks to Cadrix only from inside the VM with a per-node token that is never shown in the UI.
• One password protects the Cadrix UI, hashed with Argon2; mobile devices use their own revocable tokens.
• Acceptable use: no mining, spam, scanning or attacks; port 25 is closed. See the terms and privacy policy.