Agents that work as a team.
Inside your rules, on your servers.
Run your own sessions, or give agents a standing job. A squad takes an objective with measured key results: a manager agent plans the work, workers run in their own sandboxes on the Frazer harness or a harness you choose, a verifier checks, and the accountable person approves the plan and what ships. Start from a preconfigured image; talk to them from any client.
- A
- An objective, measured by FrazerKey results come from real sources, with a guardrail beside each. Agents never write the numbers.
- B
- A manager that cannot approveIt plans inside a plan a person approved. It can never approve, grant access or change budgets.
- C
- A verifier on every resultAnother model family, or the Reviewer, passes or rejects work at the exact commit, with proof.
- D
- People stay in chargeMerges, production writes and grants wait for a person with step-up. Budgets stop work before spend.
One objective in.
Verified, measured work out.
Give agents an outcome.
Frazer measures it, not the agents.
An objective has key results read from real sources (incidents, deploys, CI, your tools) and a guardrail from a different source beside each. The manager turns it into campaigns that run in waves with their own budgets and kill switches. If a guardrail breaks, or nothing moves for three check-ins, the campaign stops and a person decides.
Start from an image.
Change what you need.
Four Frazer tiers, or your own image layered on one. Packages and the harness are baked and cached; skills, tools, knowledge and models are an overlay applied at wake, so changing them needs no rebuild. Every image is built in an isolated builder, scanned, signed and promoted from dev to staging to prod.
Same image family as CI runners and devboxes: an agent taking over a box session finds the same tools.
kind: AgentImage
metadata: {name: acme/coding}
spec:
from: frazer/agent-full@2026.10.1 # a Frazer tier, or another image of yours
harness: claude-agent-sdk@0.9.4 # or frazer-agent, openclaw
packages: {apt: [protobuf-compiler], go: [golangci-lint@v2.6]}
class: {default: full-4}
warm: {pool: 1, snapshot: after-ready}
overlay: # applied at wake, never baked
skills: [acme/go-upgrade@3.1]
mcpServers: [frazer, github, linear]
knowledge: [acme-engineering]
models: {main: balanced, subagents: fast}# Plan → ImageBuild in an isolated builder
$ frazer agents images build acme/coding -f image.yaml
# dev → staging → prod, moved by digest
$ frazer agents images promote acme/coding@v24 --to prod$ frazer agents images build acme/coding -f image.yaml
Plan isolated build · SBOM · scan · sign · smoke eval
✓ acme/coding@v24 · 0 fixable critical or high · signed
$ frazer agents images promote acme/coding@v24 --to prodYour harness or ours, inside.
Same cell, same gates.
Bring the agent framework your team already uses. Frazer runs it in a microVM per agent and keeps everything with authority outside: channels, model keys, tool tokens and secrets are reached through Frazer’s gateways, never stored where the agent can read them.
One session, wherever you are.
Start in Slack, finish in your editor.
Every client reads and continues the same sessions with one of three access levels: Chat, Drive (take over a terminal or browser) or Operate (pause, restart, edit). Approvals never travel through a client token or a chat message; they open in a signed-in Frazer surface with step-up.
Autonomy you can bound.
And stop in one click.
Grants
Each agent is a principal with its own roles, tools and knowledge scopes; it acts for a person, never as them.
Ask before
Production writes, merges, secret access and outbound messages can require a person, with step-up.
Budgets
Task, campaign, objective, squad and project, each checked before the next call; nothing is spent past a cap.
Limits
By default 25 agents per person, 12 per manager, squads two levels deep, sub-agents two levels deep.
Kill switch
For a campaign, a wave, an agent or the whole organization; quarantine keeps the evidence.
On the record
Every step is traced and every write is a plan with an audit entry; memory is readable and editable.
Agents and whole squads.
Each one a template you can edit.
Personal assistant
Mail, calendar and reminders over Telegram, Slack or email.
always-on · personalOn-call agent
Reads alerts and deploys; restarts and rollbacks wait for you.
always-on · teamPR shepherd
Keeps pull requests moving: rebases, fixes CI, asks reviewers.
triggered · teamSupport triage
Answers from your handbook; drafts replies for a person to send.
always-on · teamResearch agent
Browses and reads, writes a sourced report to one channel.
triggered · teamCoding agent
From an issue to a draft pull request with proof.
triggered · projectSquad manager
Runs an objective with workers; reports every evening.
squad · teamOvernight orchestration
Works a signed goal overnight; morning report first.
supervisor · team
No seats.
Pay while agents work.
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.
See every priceAgents, answered.
Can I run my existing OpenClaw agent?
Yes. OpenClaw is a first-class harness: Frazer runs it in a managed cell, one gateway per microVM per trust boundary, with Frazer’s identity in front and the control UI never exposed. frazer agents import openclaw brings over its agents, channels, schedules, skills and models; secrets are entered again into the credential broker, never copied.
Can I run agents for my own customers, with their own wallets?
Yes. Each of your customers becomes a sub-tenant with its own cells, channels, memory and a prepaid wallet with auto-recharge and invoices. You price the usage; Frazer adds no fee on top-ups and bills your project as usual.
What can a manager agent never do?
Approve, grant, change rules, budgets or its own hiring policy, buy servers or lift a quarantine. It plans inside a plan a person approved, its workers act with no more than its own grants, and no agent treats another agent’s message as approval.
Where do my prompts, code and memory go? Are they used for training?
They stay in the agent’s sandbox and its encrypted volume, on your servers or the Frazer fleet; memory is readable, editable and can be forgotten or exported. Model calls go through Frazer’s LLM gateway, which logs metadata only by default, offers zero data retention per project, and can block any route that would send your data to a provider that trains on it.
Can agents run on my own servers and models?
Yes. On your own servers each agent runs in its own microVM, and the runtime is part of the server fee. Models come through the LLM gateway: frontier models with your own key at no markup, or open models you run on your own GPUs.
What happens when a squad hits its budget?
Work stops before the spend, not after. Budgets nest (task, campaign, objective, squad, project) and each is checked before the next model or tool call; a campaign warns at 80 % and stops at 100 %. Only the accountable person can raise the budget or resume the campaign.