The new standard for
engineering with agents.
An environment, not an editor.
When agents do most of the typing, the work changes shape: you set direction, approve and review, and the work runs in parallel on real machines. Frazer’s ADE is the whole environment for that: the Frazer app and the editors you already use, devboxes, agents and squads, company Knowledge, Frazer Reviewer, GitHub runners and cache, and the cloud you deploy to, under one identity, one set of rules and one audit trail.
- A
- Needs you, in one listA plan to apply, one question asked by 212 sessions, a production approval and an agent that wants to send mail.
- B
- Work running without youA fan-out at 412 of 1,000, a squad on its objective, sessions that keep going when the laptop closes.
- C
- One key to start anythingA session, a fan-out, a deploy, a box or an agent, from a composer that picks the model route, the agent and the box.
- D
- Real machinesBoxes on named servers, a GPU box asleep until you wake it, and boxes a teammate shared with you.
Agents do the typing.
You direct, approve and review.
The scarce resource is no longer keystrokes or compute; it is your attention. So an ADE runs work in parallel, checks it before it reaches you, and asks you only for the decisions that need a person.
| An editor with an agent in it | The ADE | |
|---|---|---|
| Where work runs | On your laptop, one session at a time | On real machines: your devbox, and a microVM for every session of a fan-out |
| How much at once | As many tabs as you can keep an eye on | Designed for 1,000+ concurrent sessions per organization; 100 per person by default |
| Context | Whatever you paste in | Company Knowledge, skills and MCP servers on every box and agent, with each person’s permissions |
| Review | Every diff, by hand | The Reviewer and a verifier check first; you review clusters of similar results |
| Shipping | Your own tokens, scripts and deploys | One plan to apply; production waits for a person with a passkey |
| Spend | Found on next month’s invoices | Budgets per item, run, agent and project that stop before they spend |
| Record | Spread across every tool | Every write is a plan with an audit entry: who, on whose behalf, and why |
Not one app.
The whole environment.
An editor with an agent in it helps one person type faster. An ADE is everything around the work: the machines it runs on, the agents that do it, the knowledge they read, the gates that check it and the cloud it ships to. Frazer builds every part, so they share one identity, one set of rules and one audit trail.
- Frazer appThe front door: sessions, runs, triage, squads, Knowledge, deploys and your Inbox in one window.
- DevboxesReal machines with local NVMe, set up for your company, shared by role.
- Agents and squadsSessions, standing agents and squads, from preconfigured images, with budgets.
- KnowledgeYour code and company knowledge, with each person’s permissions on every answer.
- Frazer ReviewerEvidence or silence, and a verifier from another model family.
- GitHub runnersCI in a microVM per job, lanes for agent PRs, one warm cache.
- The cloud you deploy toKubernetes, serverless, databases and Frazer Monitoring, on any hardware.
- Under all of itOne identity, one set of rules and one audit trail: IAM, approvals, budgets, the LLM gateway.
A thousand sessions,
and you stay in charge.
Nobody watches a thousand sessions. The ADE splits the job into three parts it can carry for you: it fans the work out, holds every session inside guardrails, and brings results back as decisions.
- 01 · Fan out
One prompt. A thousand items.
One prompt with variables over a catalog query, repositories, tickets or a list. A dry run on three items first, then waves. Each person runs up to 100 sessions at a time by default, and an admin can raise that to 1,000; the rest queue instead of failing.
A thousand sessions - 02 · Guardrails
Every session inside your rules.
Each session runs in its own microVM with short-lived grants. Budgets per item and per run stop before the next model call, and a kill switch trips on failures, a broken guardrail or no progress. Agents never approve.
Stay in charge - 03 · Review
Decisions, not a thousand diffs.
The Reviewer and a verifier from another model family check every result at its exact commit. You review clusters of similar changes, a representative and three spot checks, then open draft pull requests in batches.
How it works
Frazer is designed for 1,000+ concurrent sessions per organization: a target, not a measurement.
The Frazer app is the front door.
Your editor is welcome too.
The Frazer app, built by Frazer with its own agent engine in Rust, puts the whole ADE in one window: sessions on your box, fan-out runs and triage, squads, Knowledge, the deploy sheet, Cloud and your Inbox. Close the laptop and the work goes on.
Prefer your editor? The Frazer extension brings sessions, boxes, approvals and Plan cards to VS Code and the editors built on it, and JetBrains connects through Toolbox. Same boxes, same rules.
- Resume anywhereSessions live on the box, not the laptop; pick them up on another device.
- Every toolEach Frazer product is a panel, a palette command or a slash command.
- One identityOne sign-in, one device check, one revoke for every way in.
See it end to end.
How it works
One piece of work, from a prompt to production, in eight steps on the real screens.
A thousand sessions
Fan-out, waves and budgets, where sessions run, and how results come back.
Stay in charge
Approvals, budgets, guardrails, grants and Secrets, audit and the kill switch.
Tour
Twelve screens of the Frazer app, and every way into the ADE.
Is this an IDE?
An IDE is an editor. The ADE is the environment around it: the machines your sessions run on, the agents and squads that work in parallel, the knowledge they read, the reviewer that checks their work, the CI that proves it and the cloud it ships to, under one identity. The Frazer app is how you open it; your editor still edits.
Do I have to switch editors?
No. Work in the Frazer app, or keep VS Code or an editor built on it, with the Frazer extension, or JetBrains through Toolbox. Zed, a terminal and the browser reach the same box. Every way in opens the same boxes, sessions and approvals, with one sign-in, one device check and one revoke.
What runs where?
Your laptop runs the app or your editor and holds nothing long-lived. The Frazer agent and your sessions run on your devbox, a VM on a server you can name. Fan-out sessions and managed agents run in their own microVMs; CI runs on GitHub runners, a fresh microVM per job; what you deploy runs on Kubernetes or serverless. All of it on your servers, your cloud accounts or the Frazer fleet.
What does it cost?
On servers you bring, devboxes, agents, GitHub runners and Knowledge are part of $1.50 per physical core a month, and your first server with up to 16 cores is free. On the Frazer fleet you pay by the second: devboxes at $0.030 per vCPU-hour plus $0.007 per GiB-hour, agent sessions at $0.05 per active vCPU-hour, and only storage while asleep. Models cost the provider’s price plus 5 %, or nothing extra with your own key. Squads and campaigns cost nothing by themselves; their budgets cap the meters. Frazer Reviewer is $15 per active human committer a month, or $7.50 with your own model key; agent pull requests take no seat, and public repositories are free.