Surogate documentation

Surogate is a platform for building autonomous AI agents that do real work. Train an agent on the way you already work, put it in front of the people you serve, and charge for access if you want to. Everything it does is recorded, and that record is what you use to make it better.

Start here

Work mode

Chat with deployed agents, review what they did, attach skills and knowledge bases, publish to Slack or your website. Plain-language workflow guides, no code, no configuration files.

Start with Work mode → · Quickstart · Use cases

Develop mode

Design agents, write skills, wire up MCP servers and governance, build datasets, train experts, run evaluations, integrate over the API. Deep configuration and runtime internals.

Start with Develop mode → · Quickstart · Use cases

Vibecode your agents

Press ⌘+/ anywhere in the platform and describe what you want. The Copilot creates the agent, attaches the skill or the knowledge base, scales the deployment, starts the training run — no forms, no config files. It will also just answer questions: what ran yesterday, which sessions got a thumbs-down, how the sql-writer expert is performing this week. Most of what the sections below describe clicking through, you can ask for instead.

Destructive or expensive operations — deleting anything, starting a training run — show a confirmation card naming the exact resource before they run. The builder’s view lists every operation it exposes, and what it deliberately will not do.

The improvement loop

You build an agent from configuration rather than code; observe what it actually did in the session log and flag the good and bad turns; train either the cheap way — edit a skill, a persona, a knowledge base — or the expensive way, by fine-tuning an expert on the sessions you flagged; then redeploy. The builder loop walks all four phases and gives the end-to-end time for each kind of change; the same cycle without the configuration detail is Improve your agent.

Skills and expert models

A skill is a reusable procedure an agent follows for a specific task — the steps, the rules, the format of a good answer. Set type: expert on that same skill and it gains its own fine-tuned model: the skill body becomes the expert’s system prompt, and the agent consults it in a bounded mini-loop with its own tools and iteration budget instead of answering from the general model.

Pairing the two is what makes narrow, repeated tasks reliable. The skill constrains the task; the fine-tune specializes a model to exactly that task, trained on trajectories the agent has already completed successfully. The platform walks the session log, collects those successful trajectories into a versioned dataset, and trains on them — so the training data is your own production traffic rather than something you have to author.

The lifecycle is define → collect → train → activate → monitor → retrain. An active expert carries its own success-rate stats, so a specialist that degrades shows up in the numbers and can be retired in one call rather than quietly making things worse. Skill optimization works the other end of the same problem, proposing edited skills, scoring them, and keeping the best.

Charging for an agent

An agent trained on how you work is worth something to the people you already serve, so you can sell access to it. Monetize an agent and you choose the pricing — a monthly subscription, packs of tokens, or both — and set the price yourself.

You are the merchant of record. Buyers pay into your Stripe account on your normal payout schedule, your business name appears on their card statement, and Surogate takes a platform fee rather than holding the money. Buyers do not need a Surogate account of their own; they sign in through your agent and the platform enforces the token budget on every message. Agent commerce needs the Pro plan or higher — see Billing — and buyer sign-in is configured through self-registration.

Capabilities

Each row links to the page that covers it. Feature pages live in Develop mode; the day-to-day usage pages live in Work mode.

Capability	What it does
Agents	A model, persona, skills, knowledge, tools, and guardrails, deployed as a service your users can talk to.
Channels	The same agent on web chat, Slack, Telegram, an embeddable widget, or the API — sharing one memory.
Skills	Reusable procedures an agent follows for a task — steps, rules, and what a good answer looks like. Skill optimization proposes edited skills, scores them, and keeps the best.
Expert models	A skill backed by its own fine-tuned model, trained on the successful trajectories the agent already produced, consulted in a bounded mini-loop and retired in one call when its success rate drops.
Knowledge bases	Document collections searched during the conversation, so answers come from your material with sources attached.
Tools and credentials	MCP servers connect an agent to your systems and to third-party APIs; secrets stay in a vault and are never exposed to the agent’s runtime.
Browser control	Agents drive a real Chromium browser and hand control back to a person for login, MFA, or anything needing judgement.
Long-running work	Missions graded against success criteria, sub-agents for delegated parts, an inbox for approvals, and arenas — in preview — for supervised multi-agent runs.
Sessions	Every message, tool call, and result recorded and replayable. Event types explains what the log contains; reviewing sessions is the day-to-day flagging workflow.
Copilot	An agent that drives the platform itself. Ask in natural language and it calls the platform’s tools — creating agents, attaching skills, deploying models, launching training runs — with a confirmation step before anything destructive or expensive.
Monetization	Sell access to a public agent as a subscription, token packs, or both. You set the price and are the merchant of record; payouts land in your own Stripe account. Pro plan or higher.
Evaluations	Score an agent or a model against 40 built-in benchmarks, or a custom benchmark built from your own failed sessions, then A/B two candidates before promoting either.
Models	Catalog, serving endpoints with quantization and autoscaling, and versioned rollback — or bring your own LLM per agent. Runs execute on the providers you attach under Compute.
Training	Supervised fine-tuning, LoRA and QLoRA adapters, mixture-of-experts and long-context runs distributed across several GPUs and nodes, and reinforcement learning against verifiable rewards or an LLM judge.
Datasets	Training and evaluation sets built from real sessions, uploads, or synthetic generation — profiled, scanned for PII, and versioned in the Data Hub.
Security and governance	Guardrails are locked when a session starts and cannot be weakened mid-task, sandboxed code is network-restricted, integrations are scanned for tampering, and every action lands in the event log. See how the runtime behaves.

Reference

Tool catalog · Event types · Background jobs · Coordination & the board · Troubleshooting · Glossary for Work mode and Develop mode

Open source

Three components are developed in the open under AGPL-3.0: surogates (the agent runtime — harness loop, sessions, sandbox, governance, MCP), surogate (the SFT and RL training framework behind expert models), and surogate-hub (versioned storage for skills, datasets, and models).