Everything Ergates does

• Columns that mean work: dragging a card to an agent's column means "do it (again)". Analysis, design, build, review, release and Delivered follow one another.
• Gates for people: only you move a card on from Ready for dev, Approved and Release. Nothing reaches production without your click.
• Questions as a checklist: the analyst puts its questions on the card as checkboxes. You answer in a comment or tick a box, and the analyst carries on by itself.
• A comment wakes the agent: reply on a blocked card or a card in analysis and the right agent picks it up again, and can open new cards itself.
• Questions get an answer, not a pull request: an analysis, or a question about how an app works, comes back with an answer in Delivered.
• Files and screenshots: drop files of up to 25 MB on a card, and paste screenshots straight into text and comments.
• Big cards in parts: what is too big for one pull request is split up and built by a swarm of developers at the same time.
• Done as a summary: the Done column shows a counter and a word cloud of what was built, with a changelog per release. "What's done?" shows it per release or per week.
• Cancel with a reason: cancelled cards get a reason from a set of chips; the counter shows why work stopped.
• Live: the board updates live (server push), and actions feel instant.

Limits live in code: an agent cannot do more than its role allows, whatever its file says.

• Clickable prototypes in Claude Design: the designer makes a prototype for each card; every version is kept.
• View the design in the cockpit: each version of the prototype opens in a panel next to the card.
• Your own design as the basis: give a link to your design or design system and the designer follows it.
• Claude artifacts on a card: paste an artifact link (document, deck, canvas) on a card; the analyst, the designer and the developers read it too.
• Approve on a deck: the analyst sums up its plan in an approval deck; the Markdown stays the source.
• Documents as pages: what agents write (specs, analyses, plans) is a readable page on the board, not a loose attachment.

• A workspace per run: every agent works in its own git worktree and sandbox; parallel runs stay out of each other's way.
• Lanes and a ceiling: a lane per app and per kind of work, with a real limit on how many runs go at once. A waiting card says so in one word.
• Layered verification: while building, the related tests run; once per commit, the full list, split across shards.
• Warm runs: cached dependencies, template databases and a memory per app make runs faster.
• Releasable branches: main and develop always stay releasable; a pull request that falls behind is brought up to date.
• Its own builder: Ergates builds images itself with rootless BuildKit, without privileged containers.
• No building past a person: when a card is waiting for your answer or your key, nobody builds on.

• Promote with one button: "To uat" and "To prod" on Today and on the card; the trail dev ✓ · uat · prod shows where a change is.
• Bundled releases: cards that are on Release together go live in one prod deploy.
• Zero downtime: the app runs blue/green next to a separate data stack; you can roll back by image tag.
• A network per app: every app stack gets its own network.
• Create servers at Hetzner, from the cockpit: Ergates creates a new server at Hetzner itself. You choose the location and server type (with the price per month), an SSH key and the firewall (80 and 443, and 22 if you want); Ergates installs Docker and its deploy agent, and the server is ready for deploys. Deleting only works after typing the server's name, never automatically. Off by default until you turn it on.
• Any server, per environment: dev, uat and prod can each run on a different server: your own server, a VPS at any provider, or a client's server. Connecting takes one install command; the agent on that server only calls out, so there is no open management port.
• Its own deployer: Ergates deploys by itself, tells you which commit is live and waits until its agents are done.
• Carry keys over: take an environment's keys along to the next one in one action.
• Keys only you have: the analyst names which keys are needed; you fill them in under settings, never in a chat.
• Domain, DNS and TLS: sysops handles compose, DNS (through Cloudflare zones) and certificates per app.
• Mail per app: apps send and receive mail through their own mail stack, with a test inbox for dev.

• A new project in a few steps: start an app from the cockpit; Ergates creates the repository, the stacks and the board.
• Import, after checking the fit: give an existing repository (private ones too) and a scan in a sandbox tells you whether it fits, before anything is copied.
• Archive or delete: archiving or deleting an app cleans up its Docker leftovers too; the repository stays, archived.
• Add-ons: extensions with a manifest and a small typed API, with their own pages inside the cockpit.
• Add-ons with MCP tools: an add-on can offer tools to agents and to Claude, split into read and write; per add-on you turn writing on or off (read-only by default). An add-on only gets the environment variables you allow.
• Agents as files: add or change agents as .agent.md files.

• Today: what is waiting for you and what is ready to wrap up, grouped by action (answer, promote, read), with a progress bar and a priority filter. Next to it, a narrow column with what is running now.
• ⌘K: search cards, projects, pages and every setting from the keyboard.
• Project switcher: switch projects from the menu.
• Settings per project: six sections with one save bar; for every field you see where its value comes from and what changed. This is where you set up the project's team (agents and specialists).
• Platform settings: defaults for every project, a version check, and a danger zone where you type the name to confirm.
• English and Dutch: the cockpit is in English by default, with an EN | NL switch.
• Mobile: the cockpit works at phone size, with a More page.
• Ergates repaired itself: shown on Today and on the card when the platform put something right by itself.

• Self-repair: errors are classified; Ergates repairs platform errors itself. A run that hits its time or turn limit carries on instead of stopping.
• Watchdog and startup check: stuck runs are noticed and resumed; on startup, Ergates cleans up half-finished runs.
• A reason for every block: a blocked card always says why, and triage picks a rescue.
• Safe updates: an Ergates update waits until no agent is working any more, so nobody is interrupted.
• Ergates' own errors: are reported to Ergates as a card.
• Status page: the queue, what is running, keys, and what is left of your Claude subscription.
• Your own domain: Ergates' domain is a setting.

• Self-hosted: Ergates and all your apps run on your own server.
• Your own Claude subscription: no extra AI billing; the status page shows what is left.
• People decide: the gates for development, approval and release always stay with a person.
• Isolated runs: agents work in sandboxes behind an egress proxy; scans of imported code run separately.
• Keys kept apart: secrets live in the settings, never in the repository or in card text.
• Permissions in code: what an agent may do is fixed in code, not only in its instructions.

• More languages and app types (Flutter, possibly Rust)Coming soon
• Login and multiple usersComing soon
• Multiple Claude accounts, each on its own usageComing soon