AUTONOMOUS AI AGENTS
Multiply yourself
Build autonomous workers for any task. Give them knowledge and tools, skills and LLMs, set their rules and watch them perform 24/7.
Deploy them everywhere or sell them to your customers.
What Surogate is
The factory for AI Agents
Design an agent, deploy it as a managed service, watch every session it runs, and tighten it as you go - guardrails, knowledge, skills, or a model trained on your own work.
One platform for the whole life of an agent.
Design agents from a model, your knowledge bases, your tools and skills - and the guardrails they must respect. No code.
Deployed for you in the cloud, on your channels, around the clock - escalating anything that needs a human.
Every session recorded and replayable. Edit a skill, tighten a rule, or train an expert model you own.
Publish the agent, set your own price, and charge for access - paid into your own Stripe account.
Work mode
Run your agents
Far more than a chatbot - a capable digital worker. That agent, and every one on this page, lives in the same two places. Work mode is for the people using deployed agents day to day: talking to them, handing them long work, and approving whatever needs a human.
Hand an agent a task and it follows a multi-step process to completion - deciding, using your systems, delivering a finished result rather than a suggestion. If a run is interrupted it resumes where it left off.
Point it at your documents, sites and repositories. They are compiled into a knowledge base it searches and cites, so answers come from your material rather than the model's guesswork.
Attach a ready-made toolkit, a server from your library, or any MCP server by its address - over a thousand of them. It can also drive a real browser: navigate, click, type and read a page like a person would.
Long-running work graded against success criteria, delegated parts handled by sub-agents, and an inbox where approvals wait for a human.
The same agent on a hosted chat page, Slack, Telegram, WhatsApp, a widget on your site, or a pipeline over the API - every channel reaching the same agent, with the same skills and the same guardrails.
Every message, tool call and result is recorded and replayable. Flagging a turn is what feeds the next round of training.
Tool access and network egress are locked when a session starts and cannot be weakened mid-task. Code runs sandboxed, credentials stay in a vault the agent never reads, and every action lands in a durable event log. Enterprise adds SSO, RBAC, dedicated compute and an SLA.
Monetization
Sell access to the agent you built
An agent trained on how you work is worth something to the people you already serve. Publish it, set your own price, and charge for access - a monthly subscription, packs of tokens, or both.
Buyers pay into your own Stripe account on your normal payout schedule, and your business name appears on their card statement. Surogate takes a platform fee rather than holding the money.
They sign in through your agent with self-registration, and the platform enforces the token budget on every message - so a heavy user cannot quietly cost you more than they pay.
Subscription, token packs, or both, at the price you choose. Agent commerce is available on the Pro plan and higher.
The improvement loop
Build, observe, train, redeploy
Every agent moves through the same four phases, and each one has an honest cost: editing a skill lands in minutes, fine-tuning an expert takes hours. Watch it cycle, or click a phase to dig in.
Assemble the agent from configuration rather than code: a model, a persona, skills, knowledge bases, MCP tools and guardrails.
Every message, tool call and result is recorded and replayable in the session log. You flag the turns that went well and the ones that did not.
The cheap way: edit a skill, a persona, a knowledge base. The expensive way: fine-tune an expert on the sessions you flagged.
Promote the new version behind the same endpoint, with versioned rollback if the numbers get worse instead of better.
Develop mode
Build and train them
Develop mode is where agents are designed, given a model, trained on your own work, evaluated and governed. Same platform, same project, one session log.
Pull one from Hugging Face by repo and revision, use a model already in your hub, point at OpenRouter, or bring any OpenAI-compatible endpoint.
Filter flagged conversations into training pairs, upload your own files, import a repo - or design synthetic data column by column, with a teacher writing and a judge scoring.
Supervised fine-tuning, preference optimization, reinforcement against a reward environment you write and version yourself, or distilling a teacher's distribution into a smaller student.
Serve open-weights models with quantization, autoscaling and versioned rollback - or bring your own LLM per agent and pay the provider directly. Runs execute on whatever compute you attach, from nine providers to your own machines.
Score against 40 built-in benchmarks, or a custom suite built from your own failed sessions, and read the pass-rate drift against the base. A/B two candidates and promote the one that won. Every model, dataset and run lands in your own hub as a versioned repo.
Expert models
Your own work, distilled into experts no one else can build
Fine-tune a small open-weights model on traces only you have. On a narrow task it matches a frontier model - at a fraction of the size, latency, and cost.
Every session - prompts, tool calls, approvals, outcomes - is logged with full traces, versioned per agent.
Traces become training data: filtered for success, deduplicated, labeled, and split - with lineage tracked in the Hub.
Fine-tune a small base model on your data - SFT, then GRPO or DPO to reward the outcomes you actually want. LoRA or full.
Quantized to 4-bit and served behind the same gateway, the expert takes the high-volume tasks - and keeps logging traces for the next round.
The moat isn't access to the biggest model - it's the flywheel that turns your work into experts no one else can replicate.
Copilot
You describe the work. It does it for you.
The Copilot drives the platform itself. It creates the agent, attaches the skill or the knowledge base, scales the deployment, starts the training run - and answers questions about what ran yesterday. Most of what this page describes clicking through, you can ask for instead.
Destructive or expensive operations show a confirmation card naming the exact resource first.
Ask in plain language and the Copilot calls the platform's own tools - the same ones the API exposes.
What ran yesterday, which sessions got a thumbs-down, how the sql-writer expert is performing this week.
Deleting anything or starting a training run needs a confirmation. The builder's view lists every operation it exposes - and what it deliberately will not do.
Who it's for
See what they built with it.
Surogate is a do-it-yourself platform. Each of these systems was built by the professional, on their own practice, without a line of code and without a technical team. Here is what they do.
The agents talk to every patient on WhatsApp, at the cadence the doctor set. They ask the questions he would ask, collect blood pressure, pulse, weight and medication, read a photographed lab result, and put a short report in front of him every morning. When a value leaves the range he defined, he is alerted the same hour. He can then adjust at a distance, call the patient in, or escalate.
The agents run the doctor's own protocol. They do not diagnose and they do not prescribe. Every decision stays with him
The agents take the first conversation with every new client, at whatever hour it arrives. They collect the documents, calculate the deadlines from the first message, answer procedural questions from a library the lawyers wrote and approved, and follow open cases day by day. Anything urgent reaches an attorney immediately.
The agents run the firm's own protocol. They do not give legal advice in their own name, and they never decide strategy.
The agents work with each student in short, fixed sessions, and they never hand over the answer. They find the gap underneath the lesson the student is failing, go back to it, and fill it while the class keeps moving. Parents get a weekly picture of where their child stands, and the teacher reads the same report before the next class.
The agents teach on the teacher's own method. When they don't know how he would handle something, they stop and ask him.
The agents follow each client's situation year-round, watch the deadlines, and raise a flag early, while a problem is still small and still cheap to fix.
The agents run the accountant's own review process. Decisions and sign-off stay with him.
No lines of code were written for any of these.
Stop scaling yourself.
Start multiplying.
Build your first agent in minutes - free, no code, no credit card. Deploy it to the cloud, put it to work, and come back to results.