← All writings
Engineering

Self-improving managed agents, steered by your team

Sikaru runs managed agents that improve from their own work, guided by your team's judgment.

Every team that runs agents long enough ends up building a research lab, one tool at a time. Sikaru is that lab, already built. It runs your agents in the cloud, serves their models, reads every run, and improves each agent through better context, a better harness, or post-trained weights.

Here is where your agent starts. On FrontierHarness, every harness runs the same open model, Kimi K3, on identical machines. Sikaru's baseline harness leads, even with self-improvement switched off.

SikaruMiniMax CodeCodexDSH CreatorClaude CodePiDSH PTCDSH StandardOh My PiKimi CodeDSH MinimalExo HarnessOpenCodeHermes
Pass rate
50.0%
62.2%
74.5%
86.7%
$1
$2
$5
$10
$20
Median cost per task

Quality Leader: Sikaru

86.7% pass rate · $1.84 per task

Balanced Pick: Pi

60.0% pass rate · $2.43 per task

Cost Leader: Exo Harness

$1.05 per task · 53.3% pass rate

Speed Leader: Sikaru

4m 28s median runtime · 86.7% pass rate

Numbers for other harnesses are taken from their reported results on frontierharness.org; MiniMax Code was reported separately. Sikaru ran with self-improvement off.

Why agents need to improve

Teams that run agents in production tend to go through the same stages. They ship an agent and watch it work. Sooner or later someone starts reading trajectories to understand why it failed. Then they write evals, and after a few rounds they learn which evals are worth trusting. The most serious teams start post-training models on everything they've collected.

By then, without quite meaning to, they've built a lab out of separate tools: one for traces, one for evals, scripts for datasets, and another stack for training. Each piece works. The loop that connects them, from a failed run to a tested release, is held together by a few engineers who would rather be building what customers asked for.

Frontier labs have run that cycle for their models for years. We think every agent a business depends on will need one too, and almost no team can hire a research group to run it.

All of it runs on trajectories, the full record of what an agent saw, what it called, and what happened. Whoever serves an agent's model calls already sees most of that record and usually throws it away. Sikaru serves the model and runs everything around it, so it keeps the complete record of every run and uses it to improve the agent. That lets a small team get the kind of results a frontier lab would, while spending its own time on customers.

How a change gets made

Signals reads every trajectory, the part most teams start doing by hand. A decision model flags runs worth a closer look, groups failures that share a cause, and explains why each group fails. Your team can review any flag and add signals for things only it would notice, like an agent promising a refund it can't give.

Flagged runs become tests. Evals are real tasks every new version has to pass. Environments are practice tasks built from production runs, each with a grader, that the agent is replayed against and trained on with reinforcement learning.

Then Sikaru tries fixes in three places. The context is what the agent knows: instructions, memory, skills, and examples. The harness is how the model works the task: planning, tools, retries, and budgets. The weights are the model itself, post-trained with reinforcement learning on your runs. Any of them can be the answer, so Sikaru replays each candidate against the same real runs and proposes the one with the best outcome. Your team can add fixes of its own, like a policy that changed this morning, and they go through the same tests. A person approves every change before it ships, and any release can be rolled back.

01 · Signals

Every trajectory is read

  • Refund escalated, later approved 9 runsWhy: Policy text still says 30 days
  • Order lookup timed out 4 runsWhy: No retry on the first call

02 · Evals and environments

Flagged runs become tests

EvalsReal tickets every new version has to pass
EnvironmentPractice tickets from production with a grader, for replay and reinforcement learning
  • Refund at 38 days
  • Refund at 52 days
  • Duplicate charge

03 · Three places to fix

The best outcome ships

  1. Context $Add the 45-day refund policy117 / 120 replayed ticketsBest outcome · team approves
  2. Harness $$Retry the order lookup, then escalate110 / 120 replayed tickets
  3. Weights $$$RL post-train on 120 refund runs114 / 120 replayed tickets
The lab for the support agent: Signals groups the failures, the flagged runs become evals and a practice environment, and the fix with the best result on replayed tickets goes to the team for approval. The runs, fixes and scores are an example.

Here is the same support agent through a full run, from a refund ticket to the release that fixes how it handles refunds.

Step 12 of 12 · Lab

The new version goes live, so the next refund ticket gets the right answer.

Where work arrives

  • EmailWrite to its own address
  • SlackMention it in a channel
  • HTTP and SDKCall it from your product
  • CLIRun it from a terminal
  • SchedulesWake it on a timetable

Sikaru runs the agent in the cloud

  • Durable sessionCheckpoints every turn, so a crash or a deploy doesn’t lose the run.
  • HarnessInstructions, skills, memory and budgets, versioned as releases.
  • InferenceSikaru serves the model calls and records each one.
  • SandboxIts own cloud machine per session, or your machine when you want it.
  • ToolsApps and MCP servers, with credentials in a vault and every action logged.
  • Run recordEach step, tool result, cost and outcome, saved as a trajectory.

The lab fixes to context, harness or model weights, found, tested and shipped

  1. SignalsFailures that keep coming back
  2. Fixes come from
    • AutonomousSikaru drafts fixes from the runs
    • Your teamPeople add rules, checks and goals
  3. EvalsFixes tested on past runs
  4. Your team approvesReads the diff and the results
  5. ReleaseLive, and easy to roll back

↺ The next run uses the new release

Run log

  1. ticketticket · “Can I get a refund on order 4821?”
  2. resumesession · started · checkpoint 0
  3. thinkmodel · plan: check order → check policy → reply
  4. actsandbox · order 4821 · delivered 38 days ago
  5. connecttool · billing.refunds.lookup · read-only grant
  6. recoversession · worker replaced · resumed at step 9
  7. recordrecord · escalated: outside 30-day window
  8. noticesignal · 9 of 120 refund tickets escalated that support later approved
  9. draftteam · policy added: refunds allowed up to 45 days
  10. testeval · candidate 117/120 · live release 108/120
  11. approvereview · approved by support lead
  12. shiprelease · new version live · rollback ready
One support agent, from a ticket to a better release your team approved. The run, its numbers and the policy are an example.

This is what the support lead reviews. Sikaru drafted the second half after seeing refund tickets escalated that support later approved, and the lead added the new policy window.

support-agent · instructions.md
 ## Refunds-Refunds are allowed within 30 days of delivery. Escalate anything older.+Refunds are allowed within 45 days of delivery.+Before escalating a refund, check the delivery date in the order history+and quote it in the escalation note.

Beside the change, the lead sees how the new version did on past refund tickets: more resolved without a person, and none of the good ones worse. One approval, and the next refund ticket gets it right.

Every agent improves the same way. Some lessons it finds in its own runs, and some only your team knows.

Improves on its own

Your team steers it

GTM agent

Learns which research sources lead to replies

Sets this quarter’s ideal customer profileSales ops

Support agent

Learns which refund cases always end in an escalation, and hands them over sooner

Adds the new refund policy the day it changesSupport lead

IT agent

Learns which access requests always get approved, and prepares them ahead of time

Adds the offboarding checklist for contractorsIT lead

Autoresearch agent

Learns which experiments are dead ends, and stops running them

Points it at p95 latency instead of throughput this monthResearch lead

Fixes from either column go through the same tests before release. The lessons are examples.

A fix can look good on the runs it was tested against and still be wrong in general. That's why every fix is also tested on runs the agent already handled well, why a person signs off, and why releases can be undone.

What Sikaru runs underneath

Most of the work in running an agent sits outside the model call. Sikaru handles it:

  • Every turn checkpointed, so long runs survive crashes and deploys
  • Private conversation history, condensed before it outgrows the context window
  • Memory shared across a team or kept per person
  • Any model in the Sikaru catalog, behind one API
  • A sandbox and workspace per session, or your own machine when the work needs it
  • Your apps and MCP servers, with credentials in a vault and per-agent grants
  • Skills, subagents, and messages that steer a run already underway
  • Sign-off from a person before risky actions
  • Email, Slack, HTTP, and the CLI to reach it, and schedules to wake it
  • Caps on time, tool calls, and spend
  • The full trajectory of every run

Agents keep working after you close your laptop.

  • GTM agentWorks every inbound lead in minutes, keeps the CRM current, and sends the team a daily pipeline brief.HubSpot · Gmail · Slack
  • Support agentResolves tier-one tickets end to end and escalates the rest with a summary.Zendesk · Slack
  • IT agentHandles access requests, onboarding, and offboarding across your apps, with approvals in Slack.Google Workspace · Jira · Slack
  • Autoresearch agentRuns inference experiments overnight, measures latency and cost, and writes up what won.Your GPU machines · nightly

Sikaru managed agents

  • ChannelsEmail, Slack, HTTP, CLI
  • IdentityVaulted credentials, scoped grants
  • MemoryShared and per person
  • SandboxesA machine per session
  • SchedulesAgents that wake themselves
  • Durable runsResume after a crash or deploy
LabTurns runs into tested fixes to context, harness or model weights, with your team’s input
InferenceModels served by Sikaru, every call recorded
The same platform sits under each agent. The four agents are examples.

Setting one up

An agent is a name, a model, instructions, and the tools it may use.

Creating a coding agent on Kimi K3, browsing the tool catalog, launching it, saying hi, and adding a weekday schedule.

Or do it from the CLI: describe the agent in agent.md, create it, and run it. The last command keeps the agent in the cloud and runs its tools in your current directory.

zsh · ~/projects/app
sikaru agent create support-agent --project <project-id> --file agent.mdsikaru agent run support-agent --project <project-id> "Summarize today's escalations"sikaru agent run coding-agent --project <project-id> --compute local "Fix the failing test"

When Sikaru fits

Sikaru is for business-critical agents that do real work over and over: long tasks, real tools and credentials, and people relying on the results. If the work is one question with no tools, skip the agent and call a model directly.

zsh · ~/projects/app
sikaru inference chat moonshotai/kimi-k3 "hi"Hi there! How can I help you today?

Both use the same API key and SDK, so a single call can grow into an agent when the work needs tools.

Private beta

Sikaru is in private beta, and we're working with teams whose agents are critical to their business and need to keep getting better. If you want those agents to be the most delightful AI experience in your category without building a research lab first, we'd like to partner with you.