Frazer Agents

Frazer Agents hosts, wakes and supervises always-on and triggered agents. Each agent runs in its own microVM on your servers or on the Frazer fleet. It acts as its own principal, with grants, a budget and action rules, and it never holds a stored credential. You talk to it from the console, the Frazer app, Slack, Teams, email, Telegram, your editor or any MCP client. Every step it takes is traced and audited.

Product page: Frazer Agents.

How it works

An agent is a resource in a project (projects/{project}/agents/{agent}). Frazer keeps everything that carries authority outside the agent’s sandbox. Channels, model keys, tool tokens and secrets are reached through Frazer’s gateways, so the agent can use them but never read them.

• Kind: always_on (wakes on heartbeats, schedules and messages), triggered (starts on an event or a task) or supervisor.
• Scope: personal acts for its owner, and only the owner reads its transcripts and memory. team acts for a group. project acts for the project’s service identity.
• Harness: the agent loop inside the sandbox, chosen for every agent as a harness profile. The Frazer harness, Frazer’s own agent engine written in Rust and the engine of the Frazer app, is the default and can use a different model for each step. OpenClaw runs as a managed cell. The popular harnesses (Claude Code, Codex, Gemini CLI, GitHub Copilot, OpenCode, Hermes and more) run certified against a compatibility suite under the same host guarantees, vendor harnesses on your own vendor credential, and your own harness through the harness contract. Try and compare them on your own work: Harnesses.
• Image: what the sandbox boots, either a Frazer tier (Lite, Standard, Full, GPU) or your own image. See Agent images.
• Session: one conversation or run, kept as a Fir session: the whole log, resumable on any machine or harness. The same session continues in the console, the Frazer app, Slack, Telegram or your editor, and an agent’s commit needs one.
• Wake: what starts a turn: a heartbeat, a schedule, a follow-up the agent set itself, a subscription or an event.
• Channel binding: a channel connection with its DM policy and identity rules. Channels end at Frazer’s agent gateway, never inside the agent.
• Memory: workspace files, facts, episodes and browser profiles. Every item records who wrote it and where it came from, and you can read, edit, pin and forget it.
• Skills: skill folders in the open format, pinned by digest in each session’s skill lock: Skills.
• Action rules: every action pattern maps to Auto, When told, Ask or Hand off.
• Budget: caps per run, agent, team and project, checked before the next model or tool call.

Where an agent runs

Each agent gets one microVM and a persistent, encrypted volume for its workspace, memory files and browser profiles. On your servers it runs in a hardware-isolated microVM on an agent pool of its project, or one shared to it. On the Frazer fleet it runs in a microVM too. Personal agents of one organization never share a VM. On the fleet, Lite and Standard microVMs of different organizations may share a host, with per-organization egress and no shared snapshots; Full and GPU agents, and any squad or project that asks, get dedicated hosts.

State	What it means	What it costs
Running	Working on a turn	Runtime
Idle	The VM is up between turns, 15 minutes by default; a session that waits on CI, a queue, a review, a person or a provider’s reset suspends at once	Runtime
Suspended	A memory snapshot is kept	Storage
Sleeping	Only the volume is kept, after 4 hours idle	Storage
Archived	After 30 days without a wake; the volume is kept per retention	Storage

A waiting session is billed for its snapshot’s storage only, and returns to running in under a second (target).

Frazer journals each model call and tool call with an idempotency key, so a crashed run resumes from its last step without repeating a side effect. Waiting for a person holds no compute.

Create an agent

1. Choose a template. Each one sets the kind, scope, harness, routes, channels, wakes and rules, and you can change any of them.

   Template	Kind and scope	What it does
   Personal assistant	Always-on, personal	Mail, calendar and reminders over Telegram, Slack or email
   On-call agent	Always-on, team	Reads alerts and deploys; restarts and rollbacks wait for you
   PR shepherd	Triggered, team	Keeps pull requests moving: rebases, fixes CI, asks reviewers
   Support triage	Always-on, team	Answers from your handbook; drafts replies for a person to send
   Research agent	Triggered, team or personal	Browses and reads, writes a sourced report to one channel
   Coding agent	Triggered, project	From an issue to a draft pull request with proof
   Overnight orchestration	Supervisor	Works a signed goal overnight; morning report first

2. Create the agent.

   CLI

   frazer agents create lena-assistant --template frazer/personal-assistant \
     --scope personal --channel telegram --heartbeat 30m --budget 5/day

   Add --dry-run to print the plan first: the quota impact, policy checks and estimated cost.

   Console

   Open Agents › Templates, choose a template, then pick the harness, the image and, for a worker, its squad. The form shows an estimate before you create the agent. Configuration switches between the form and YAML.

   YAML

   oncall-pilot.yaml

   apiVersion: frazer.ai/v1
   kind: Agent
   metadata: { name: oncall-pilot, project: acme-production }
   spec:
     kind: always_on
     scope: { type: team, group: platform-oncall, owner: tomasz }
     template: frazer/on-call@3
     engine: frazer-harness
     models: { main: balanced, subagents: fast, heartbeat: fast } # LLM gateway routes
     skills: [frazer/runbook-runner@0.9.4, frazer/pagerduty-ack@1.1.0]
     tools:
       frazer: { toolsets: [observe, deploys, k8s.read], ceiling: viewer }
       connections: [{ name: slack-acme, capabilities: [notify.send] }]
     channels: [{ connection: slack-acme, dm: allowlist, channels: ["#acme-oncall"] }]
     wakes:
       - { kind: heartbeat, every: 5m, activeHours: always }
       - { kind: self, maxPerDay: 12 }
     sandbox: { runtime: microvm, vcpu: 2, memoryGiB: 4, egress: { preset: trusted } }
     rules: rules/oncall-standard
     budget: { perDayUsd: 20, perRunUsd: 3 }

   frazer apply -f oncall-pilot.yaml

3. Pair your channel account. For Telegram, print a pairing code and send it to the agent’s bot from your own account:

   frazer agents channels pair lena-assistant --telegram

   The code has 8 characters and is valid for 1 hour. After 5 wrong tries it locks; run the command again.

4. Watch it work. Agents › Runs and traces lists every run. A run’s Trace tab shows each model call, tool call, approval wait and memory write, with the cost of each span.

Talk to an agent

In a session

My sessions is a chat workspace in the console, and the same sessions open in the Frazer app. Choose a model (an LLM gateway route), an agent and a target:

• No compute: the agent runs in Frazer’s shared session runtime with no shell; tools come only through MCP.
• Sandbox: a microVM for this session that sleeps when idle.
• Devbox: the session runs on your devbox.

Switching target in the middle of a session hands it off with a filesystem snapshot. No-compute sessions keep their transcripts in Frazer’s session store, encrypted per organization and readable only by their owner.

frazer sessions new "Draft the October update" --model balanced --target none
frazer sessions list --mine
frazer sessions send <id> "Use the September numbers"
frazer sessions attach <id>
frazer sessions handoff <id> --to-agent oncall-pilot

Make this an agent in a session’s header opens New agent filled in from the session.

Through a channel

Channels end at Frazer’s agent gateway. It verifies the signature and the sender, rejects replays, strips hidden text, labels each message trusted or untrusted, rate-limits, and wakes the agent. If a channel fails, messages queue for 24 hours. The agent replies as its own bot identity, never as a person.

Channel	How the sender is identified
Slack (Frazer Agents app)	Workspace member linked to a Frazer user through the directory; a thread is a session
Microsoft Teams	Entra user linked to a Frazer user
Telegram	Pairing code sent from the person’s own account; one bot per personal agent
Email	SPF, DKIM and DMARC checked; known senders linked to users, others untrusted
Web widget and console	Signed-in users verified; visitors untrusted
WhatsApp Business	Opt-in number, verified, for your own customer-facing products

Each binding has a DM policy: pairing (the default), allowlist, open or disabled. A message from a linked user runs with that user’s grants, capped by the agent’s ceiling. An unlinked sender gets only what a public agent offers. Google Chat is a channel too. Personal WhatsApp and iMessage bridges are not offered.

From your own client

Client	How it connects
Hermes Desktop, CLI or TUI	Hermes remote gateway at agents.frazer.ai/{org}/{project}/{agent}/hermes, with Frazer sign-in or a token from frazer agents connect
VS Code, JetBrains, Zed, Neovim	ACP over stdio through frazer acp
Any MCP client	The agent’s own MCP endpoint: send_message, list_sessions, get_status
OpenClaw apps	The OpenClaw gateway protocol through Frazer’s proxy, with your Frazer sign-in
Your code	AG-UI event stream and REST, with an API key or OIDC client credentials

frazer agents connect oncall-pilot --client hermes-desktop   # or vscode, jetbrains, zed, mcp
frazer acp --agent oncall-pilot

A client holds one of three access levels: Chat (send messages, read the sessions you may see), Drive (also take over a terminal or browser) or Operate (pause, restart, edit). Tokens last 1 hour at most and are bound to you, the agent and the device. Agents › Clients lists them under Connected, each with Revoke. Approvals never travel through a client token: they open in a signed-in Frazer surface with step-up.

Schedule its work

Wake	What it does	Limits
Heartbeat	One short turn on the fast route inside an active window; “nothing to do” replies stay hidden	An interval of at least 1 minute (team) or 15 minutes (personal); quiet hours for personal agents
Schedule	Cron or RRULE in the project’s time zone; each run is an isolated session with a task	1,000 per organization
Self-set	The agent schedules a follow-up with a reason	12 per agent per day by default; it cannot raise its own grants or budget
Subscription	Sleeps until CI, a review, a rollout, an alert, a channel reply or a timer	Storage only while waiting
Event trigger	Frazer events, webhooks and connection events	CEL filter, preflight, dedupe; 50 per hour by default

frazer agents wakes list --agent oncall-pilot
frazer agents wakes cancel <id>
frazer agents triggers create --agent go-upgrader --source github --filter '<CEL>'

Frazer checks liveness: a heartbeat that does not start, or does not finish within its window, counts as missed.

Give it tools, knowledge and skills

• Frazer tools: MCP toolsets with a ceiling role (Viewer by default) plus named operator actions. An agent never holds more than its sponsor.
• Outside tools: connections granted to the agent, called through the Frazer MCP gateway. They are read-only unless the grant opts in to writes.
• Knowledge: knowledge bases are linked, not copied, and retrieval respects the reader’s permissions.
• Models: LLM gateway routes such as balanced, fast and max, or your own provider key.
• Egress: denied by default. The presets are none, trusted, custom and full; full needs an approval in production projects. A refusal names the blocked host and the setting that would allow it.

Skills use the open Agent Skills format for every harness. They come from your own skill repositories (synced on every merge), from handbook releases, from public skills imported through twelve checks as pull requests on your mirror repository, from Marketplace skill packs, or as drafts an agent wrote, which only that session sees until a person seals them. Each session starts with a skill lock (each skill pinned by digest), records which skills it loaded, and an update that widens reach (a new host, tool or secret) waits for a person. Skills has the registry, skill sets, analytics, evals, suggestions and gaps.

frazer skills import hub:pellwyn/team-skills/go-errors@2.3.0 --dry-run
frazer skills list --used-by agents/coder
frazer skills allow go-errors@2.3.0

Action rules decide what the agent may do alone:

Outcome	Meaning	Always
Auto	Act without asking	—
When told	Act only when the task asked for it	—
Ask	An approval card for a person	Deleting data, new sensitive access, purchases
Hand off	A person does it; the agent stops at that step	Money movement, password changes, production approvals

An action that no rule matches goes to an action reviewer from another model family. After 3 denials in a row, or 10 in the last 50 actions, the session pauses and an Agent paused: repeated denials card appears in your Inbox.

Improve an agent

Frazer improves every agent on its own, by default. When the same kind of failure repeats across an agent’s sessions, Frazer proposes a small change to the agent’s harness (a hook, a tool description, a skill or a context rule), tests it on fresh tasks from your own merged work, and rolls it out in steps. Each change is a new revision of the agent; the old one is kept, so a rollback restores it exactly.

What a change must show

• Fresh tasks. At least 12 tasks from work merged after a cut date, never only the sessions that triggered it, with each task’s result: recovered, regressed or unchanged.
• A real gain. The share of a gain that extra compute alone would buy, and the share that does not carry over to fresh tasks, are taken out; only the rest counts.
• A canary. 5 %, then 25 %, 50 % and 100 % of sessions, each step at least 24 hours and 30 sessions and long enough to see the drop your policy cares about. A canary that sees a drop rolls back by itself.
• A holdback. After 100 %, 2 % of the agent’s sessions stay on the previous revision for 14 days, so drift stays measurable. The canary shows what the holdback can detect, and by when.

Who approves a change

A person approves an improvement policy for an organization, project or agent. Inside the policy’s envelope (changes that tighten: a hook that adds a check, clearer tool text, a narrower skill), the policy approves the change after its tests and canary. Six kinds of change always wait for a person:

1. A change that widens what the agent may do.
2. A change that loosens a check.
3. A change to an evaluator: tests, graders, rubrics, verifiers or Reviewer lanes.
4. A change shaped by untrusted content that touches permissions, tools or egress.
5. A change after which guards fire less with no gain in results.
6. A change of a kind whose tests have stopped predicting real outcomes.

An agent never approves its own change. Approving a revision is a person’s step; there is no MCP tool for agents to do it.

Modes and commands

Set improve to on (the default), shadow (propose, test and qualify, then stop before approval) or off for an organization, project, agent or use. Agents can read their policy; only people change it.

frazer agents improvements list
frazer agents improvements get <step>
frazer agents improvements set-mode <scope> on|shadow|off --reason "<why>"
frazer agents improvement-kinds list --scope <scope>
frazer agents revisions explain <agent> <rN>
frazer agents revisions seal <agent> <rN> --dry-run

When a step’s budget runs out it says “Not run: no funds”; when the budget cannot pay for a decision it says “Not run: not enough budget” with the amount a decision needs. It never runs a cheaper test instead.

Install agents from the Marketplace, with budgets

An agent from the Marketplace does a job your own agents do not: security fixes, flaky tests, docs, triage, incident first response, cloud cost, testing on previews, migrations, release notes. Its listing says its job, the squad roles it can take (worker, critic, tester or verifier, never of its own work), the task kinds it accepts, the harness profiles it is certified on, the skills it ships, its permissions, its price (flat, per task, per run or per verified outcome) and its measured outcomes across Frazer, never stars, each with its configuration (harness profile, model family, task kind); it names the model families it is certified on and how it tells people it is an AI. Agents search and compare listings themselves (frazer apps search), and an install stays a person’s decision because it widens access.

1. Trial on your work (optional, recommended): a read-only run on a snapshot of chosen repositories, with no write tokens, nothing posted and no egress beyond your model gateway, the publisher’s price waived for up to 20 trial tasks, capped at $20 by default. Its proposed changes are scored by Frazer CI and Frazer Reviewer beside your current agents on the same tasks.
2. Choose the project, the sponsor, the harness profile, the permission sets, the triggers, and the squads and campaigns it may join.
3. Allocate its budget: an allocation on the installed agent, drawn from a pool (a project’s, a team’s or the organization’s budget for installed agents), with a monthly hard cap, a cap per task and per run, an optional daily pace, and alerts at 66 %, 90 % and 100 %.
4. Approve: the approval card shows the money (the price model, the estimate per task class, the allocation, the pool’s remainder, who pays) and the trial’s results.

Allocations are enforced at admission and before every model call: a task’s estimate is reserved up to its per-task cap, so a monthly cap is passed by at most what running tasks already reserved. At the cap, new tasks for that agent show Not run: no funds with the allocation that ran out, when it resets, what is waiting and one action (move budget, raise the allocation, or wait); a running task stops before its next model call with its state saved and resumes when funds arrive. If the budget check itself cannot answer, the call waits and, after 60 seconds, the task pauses with budget_check_unavailable: it never runs unchecked. Nothing is ever downgraded to fit. Budget moves between allocations inside a pool by a person with the billing role, or by an agent granted that on the pool, and the total never grows; raising a pool is a billing role’s, never an agent’s; and an agent may raise an allocation beyond its pool only inside a payment mandate a person approved with a passkey. An outcome price bills only outcomes Frazer verified from facts (merged and kept for 14 days; an issue closed by a passing check), and a reverted outcome is credited back.

frazer apps installations create flaky-fixer --project acme-production --allocation month=400,task=6,run=3 --dry-run
frazer billing budgets list --scope agent
frazer billing budgets move --from flaky-fixer --to docs-writer --amount 50 --reason "docs sprint" --dry-run

Priced per verified outcome. A publisher may price an agent per outcome (merged and kept, an issue resolved, a flaky test quieted, a finding accepted, an incident mitigated). Frazer counts outcomes, never the publisher or its agent, and only from records neither can write: merge receipts and revert links, Frazer CI’s results, an issue’s proof, Reviewer records and the incident timeline. Each outcome is a record with a signed receipt, and frazer apps outcomes verify --installation <i> --month 2026-11 recomputes every outcome of a month from your own records. Only the agent’s own work counts: a merge to which a person or another agent added commits is an assisted outcome, shown and never billed as one, and an agent never bills an outcome on an item it, its publisher or another installation of the same app filed. An outcome is charged when it happens and shown as open until its window closes; a revert, a follow-up fix, a reopened issue or a reopened incident inside the window credits it automatically. You may dispute any outcome for 30 days with a reason (frazer apps outcomes dispute); when the facts do not support it, the credit is immediate. The rules are a published, versioned document, and a change applies only to tasks admitted after it, announced 30 days ahead and counted in shadow meanwhile.

Move an OpenClaw agent

frazer agents import openclaw ./openclaw.json

The import maps agents, channels, cron jobs, skills (mirrored and scanned) and models (to LLM gateway routes). Secrets are not copied: you enter them again into the credential broker. Workspace files (AGENTS.md, SOUL.md, USER.md, IDENTITY.md, MEMORY.md, HEARTBEAT.md) load unchanged, heartbeats and cron keep their meaning, and the four DM policies are the same.

Run the agent on the Frazer harness, or keep OpenClaw as its harness. OpenClaw runs as a managed cell: one gateway per microVM per trust boundary, Frazer’s identity in front, no bot tokens in the cell, the Control UI never exposed and openclaw security audit at every start and daily. You can export the agent back unchanged.

Pause, quarantine or stop agents

Frazer runs a deterministic control loop every 30 seconds. It watches liveness, progress and spend:

• Stall: no progress for 30 minutes by default.
• Loop: the same tool call with the same arguments 5 times in 10 minutes.
• Cost pace: spend above the day’s pace line.

The loop restarts a failing agent with backoff up to 3 times, then quarantines it. Quarantine cuts the tools, mutes the channels (messages are held), freezes memory and keeps a sandbox snapshot. Nothing is deleted. A blocked skill, a Security Center finding or a person can also quarantine an agent; an Admin releases it.

frazer agents pause oncall-pilot
frazer agents quarantine oncall-pilot
frazer agents release oncall-pilot
frazer agents kill-switch on --reason "Suspicious outbound traffic"

The kill switch suspends every agent in the organization. The API, the MCP gateway, the LLM gateway and the channel gateway check it on every request. Only an Owner, with step-up, can turn it on; it also sits in Security Center and Organization › IAM › Agents and MCP as Suspend all agents.

Caution

Forgetting a memory item takes effect at once: it is removed from the store, the index and the next snapshot, and the action is audited. frazer agents memory export saves a copy as Markdown and JSON first.

Access and audit

• Identity: every agent is agent:{name} in its project, with a sponsor (the owning person or group). An agent acting for a person holds at most the intersection of its ceiling and that person’s current rights. A team or project agent runs as itself, with its own bindings, a ceiling and a sponsor.
• Personal agents: only the owner reads transcripts and memory. Admins see the name, state and cost, and can pause, quarantine or erase the agent when its owner leaves.
• Who may do what: the Operate level needs the Operator role and step-up. Releasing a quarantine and allowing a widened skill need an Admin. Raising egress to full, grants or a budget needs a project admin’s approval.
• Never: an agent token never approves anything, its own plans included.
• Audit: every action is recorded as agent:{a} on_behalf_of={sub} via={channel|schedule|session} approval=…. Client connections add via=client:{kind}. Supervisor actions are recorded as agents.supervisor.intervene.
• Traces: OpenTelemetry GenAI spans in the project’s telemetry tenant, exportable as OTLP. Replay from here reruns a run from any span on a new revision or model.
• Security Center lists every agent with its ceiling, the toolsets granted and used, egress, rules, skill verdicts, pairing attempts, injection signals and quarantines.

Messages from other agents are untrusted input: no agent treats another agent’s message as a person’s approval. Memory items derived from untrusted input are proposals until a person accepts them.

Limits and quotas

Limit	Default
Agents per person	25; an organization can raise it to 1,000
Sub-agent depth	2
Sub-agents per run	4
Schedules per organization	1,000
Self-set wakes	12 per agent per day
Event triggers	50 per hour
Heartbeat interval	At least 1 minute (team) or 15 minutes (personal)
Client tokens	1 hour at most
Telegram pairing code	8 characters, 1 hour, 5 tries
Idle before suspend	15 minutes
Idle before sleep	4 hours
Archive	30 days without a wake
Restarts before quarantine	3
Budget	Amber at 66 %, banner at 90 %, pause at 100 %

Pricing

An agent costs runtime while it is awake and tokens when it thinks. Asleep, it costs only its storage. On your own servers the runtime is part of the server fee, and there are no seats. Tokens are billed by the LLM gateway.

Frazer Agents	On your servers	On the Frazer fleet
Lite, Standard	Included	Shared hosts: $0.05 / active vCPU-hour + $0.004 / GiB-hour (Lite ≈ $0.029 / hour) · asleep: storage only
dedicated hosts	Included	Full: $0.075 / active vCPU-hour + $0.006 / GiB-hour · a whole 16 vCPU / 64 GiB host: $1.50 / hour, 1-hour minimum · GPU: the GPU price + the Full rates
Frazer Browsers	Included	$0.02 a browser-hour, billed per second, no minimum · $0.01 from the first quarterly re-read whose measured cost is at or below $0.006 a wall-hour

Every line, with the estimator: pricing.

Troubleshooting

• The agent ignores my Telegram messages. The default DM policy is pairing, and your account is not linked yet. Run frazer agents channels pair <agent> --telegram and send the code from your own account within an hour.
• A session says Waiting for you. An action matched an Ask or Hand off rule. Open the card in your Inbox and approve it with step-up, or do the step yourself.
• A Frazer write from an agent returns APPROVAL_REQUIRED. Agent writes become plans. Open the approval link in the error; see Errors.
• “Agent paused: repeated denials”. The action reviewer refused 3 actions in a row or 10 of the last 50. Read the denied actions on the card, add an action rule if they were right, then resume.
• The agent is quarantined. It ran out of restarts, loaded a blocked skill, or Security Center or a person stopped it. Read the evidence on the agent, fix the cause, then ask an Admin to run frazer agents release.
• The agent paused at its budget. It reached 100 % of a cap. Raise the budget (above the agent’s cap this needs a project admin) or leave it paused.
• A tool call fails with a blocked host. Egress is denied by default. The tool result names the host, the rule and the next call (frazer network egress-requests create). A person approves the egress plan, or you add the host to the policy as a plan; a widening runs in audit for 7 days.
• A skill update does not roll out. It widens reach and is Held. An Admin runs frazer agents skills allow.
• Every agent stopped at once. The organization kill switch is on. An Owner lifts it in Organization › IAM › Agents and MCP.

Reference

CLI

Command	What it does
frazer agents create	Create an agent from a template.
frazer agents list	List the agents in a project.
frazer agents get	Show an agent's configuration and state.
frazer agents pause	Pause an agent. Its volume and memory stay.
frazer agents resume	Resume a paused agent.
frazer agents restart	Restart an agent's sandbox.
frazer agents quarantine	Cut an agent's tools, mute its channels and freeze its memory, keeping the evidence.
frazer agents release	Release an agent from quarantine.
frazer agents export	Export an agent's configuration.
frazer agents import openclaw	Import agents, channels, schedules, skills and models from an openclaw.json and its workspace.
frazer agents run	Run an agent on a one-off task.
frazer agents wakes list	List an agent's heartbeats, schedules, self-set wakes and subscriptions.
frazer agents wakes cancel	Cancel a pending wake.
frazer agents channels pair	Print a pairing code that links your channel account to an agent.
frazer agents memory list	List the items in an agent's memory.
frazer agents memory forget	Remove a memory item from the store, the index and the next snapshot.
frazer agents memory export	Export an agent's memory as Markdown and JSON.
frazer agents connect	Connect Hermes Desktop, an editor or an MCP client to an agent.
frazer acp	Bridge an editor to an agent over ACP on stdio.
frazer agents kill-switch on	Suspend every agent in the organization. Owner only, with step-up.
frazer agents triggers create	Start an agent when an event matches a CEL filter.
frazer sessions new	Start a session with a model, an agent and a target.
frazer sessions list	List the sessions you can see, across agents, devboxes and no-compute sessions.
frazer sessions open	Open a session.
frazer sessions send	Send a message to a session.
frazer sessions approve	Approve an action a session is waiting on, with step-up.
frazer sessions attach	Stream a session into your terminal.
frazer sessions handoff	Hand a session to a managed agent.
frazer apps search	Search the Marketplace's agents by job, with their roles, task kinds, prices and measured outcomes; compare and trial complete the set.
frazer apps installations create	Install an agent from the Marketplace with its allocation (--allocation month=,task=,run=), as a plan a person approves.
frazer billing budgets move	Move budget between installed agents' allocations inside a pool, with a reason; --dry-run shows the plan.
frazer agents improvements list	List an agent's improvement steps, each with its change, its tests, its canary and its state.
frazer agents improvements get	Show one improvement step with its fresh tasks, its gain and its canary.
frazer agents improvements set-mode	Set improve to on, shadow or off for an organization, project, agent or use, with a reason. People only.
frazer agents improvement-kinds list	List the kinds of change a scope's improvement policy approves, and the kinds that wait for a person.
frazer agents revisions explain	Explain an agent revision, what changed and the evidence behind it.
frazer agents revisions seal	Approve a change that waits for a person (people only; hidden from agent identities).

All of them: CLI reference.

MCP tools

Tool	What it does
send_message	On an agent's own MCP endpoint, send the agent a message.
list_sessions	On an agent's own MCP endpoint, list the sessions you may see.
get_status	On an agent's own MCP endpoint, read the agent's state.
improvements_list	List an agent's improvement steps and their states.
improvements_get	Read one improvement step with its tests, its gain and its canary.
improvement_kinds_list	List the kinds of change a scope's policy approves and the kinds that wait for a person.
revisions_explain	Explain an agent revision. Approving a revision is a person's step; there is no MCP tool for agents to do it.

All of them: MCP tools reference.

Events

Event type	When it is sent
frazer.session.started.v1	An agent or devbox session started.
frazer.session.waiting_approval.v1	A session stopped at an action that waits for a person.
frazer.session.completed.v1	A session finished.

All of them: Events reference.

The tools above live on each agent’s own MCP endpoint. On mcp.frazer.ai, the tools that manage agents are grouped in the toolsets agents, sessions, skills and memory, and they are read-only unless a grant allows writes. The API is frazer.agents.v1.AgentService and frazer.sessions.v1.SessionService; a session streams as AG-UI events.

Related

• Agent squads: managers, workers and a verifier on one objective.
• Agent images: the tiers an agent boots, or your own image.
• Integrations: the connections agents use through grants.
• LLM gateway: routes, keys and token prices.
• Frazer app: your sessions and agents on the desktop.
• Frazer Agents: the product page.