Agents and revisions
Manage instructions, tools, and the revision each agent runs.
AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a control plane to your favorite agent harness.
Works with Claude Code, Codex, Pi, and OpenCode.
01 SELF-LEARNING
Repeated steps become reusable skills and tested workflows. Later runs reuse what works instead of planning it all again.
AgentRun turns repeated steps into proposed skills and workflows.
Proposals are checked and graded before they are accepted.
Later runs spend fewer tokens on repeated planning and tool discovery.
02 PLATFORM
Your harness handles reasoning and tool use. AgentRun manages its runs, workspace, recovery, and learning through one API.
import { AgentRun } from "@parcha/agentrun-client";
// Reads AGENTRUN_BASE_URL and AGENTRUN_API_KEY.
const client = new AgentRun();
const agent = await client.agents.create({
definition: {
version: 1,
name: "Research assistant",
instructions: "Research requests. Cite sources. Ask which aspect to focus on before you start.",
harness: "pi",
learning: true,
tools: ["web_search", "web_fetch", "ask_person"],
skills: [],
},
});
const started = await client.runs.start(agent.agent_id, {
input: { content: "Research acme.com" },
max_cost_usd: 1,
});
let run = await client.runs.wait(started.run_id, { timeoutMs: 600_000 });
if (run.pending?.kind === "question") {
console.log(run.pending.question);
await client.runs.message(run.run_id, { content: "Pricing and plans." });
run = await client.runs.wait(run.run_id, { timeoutMs: 600_000 });
}
console.log(run.status, run.result);
import { AgentRun } from "@parcha/agentrun-client";
// Reads AGENTRUN_BASE_URL and AGENTRUN_API_KEY.
const client = new AgentRun();
const agent = await client.agents.create({
definition: {
version: 1,
name: "Research assistant",
instructions: "Research requests. Cite sources. Ask which aspect to focus on before you start.",
harness: "pi",
learning: true,
tools: ["web_search", "web_fetch", "ask_person"],
skills: [],
},
});
const started = await client.runs.start(agent.agent_id, {
input: { content: "Research acme.com" },
max_cost_usd: 1,
});
let run = await client.runs.wait(started.run_id, { timeoutMs: 600_000 });
if (run.pending?.kind === "question") {
console.log(run.pending.question);
await client.runs.message(run.run_id, { content: "Pricing and plans." });
run = await client.runs.wait(run.run_id, { timeoutMs: 600_000 });
}
console.log(run.status, run.result);
from agentrun import AgentRun
# Reads AGENTRUN_BASE_URL and AGENTRUN_API_KEY.
client = AgentRun()
agent = client.agents.create({
"definition": {
"version": 1,
"name": "Research assistant",
"instructions": "Research requests. Cite sources. Ask which aspect to focus on before you start.",
"harness": "pi",
"learning": True,
"tools": ["web_search", "web_fetch", "ask_person"],
"skills": [],
},
})
started = client.runs.start(agent["agent_id"], {
"input": {"content": "Research acme.com"},
"max_cost_usd": 1,
})
run = client.runs.wait(started["run_id"], timeout=600)
pending = run.get("pending")
if pending and pending["kind"] == "question":
print(pending["question"])
client.runs.message(run["run_id"], {"content": "Pricing and plans."})
run = client.runs.wait(run["run_id"], timeout=600)
print(run["status"], run["result"])
Install with npm i @parcha/agentrun-client.Install with pip install parcha-agentrun. Set AGENTRUN_BASE_URL and AGENTRUN_API_KEY for your deployment.
The same client manages every run.
03 COMPUTE
Keep the agent loop separate from the computer doing the work. Connect your provider once; AgentRun handles commands, files, and cleanup through one API.
Run quick scripts, inspect files, and generate small reports.
Install dependencies, build, and test code in an isolated Linux environment.
Configure more CPU and memory for larger datasets and batch processing.
04 DURABLE EXECUTION
AgentRun saves the conversation, files, and completed tool results. After an interruption, recover the run from saved state instead of rebuilding its context.
Keep the same recovery API across harnesses. No need to rebuild persistence around each one.
Keep completed tool results alongside the conversation and workspace.
A new process reopens the saved state and continues the run.
import { AgentRun } from "@parcha/agentrun-client";
const client = new AgentRun();
// A stopped run keeps its conversation and files.
await client.runs.message("your-run-id", {
content: "Continue with the saved context.",
});
const run = await client.runs.wait("your-run-id");
console.log(run.status, run.result);
PLATFORM FEATURES
Connect tools. Recover interrupted runs. Turn repeated work into reusable skills.
Turn repeated steps into reusable skills and tested workflows that later runs can use.
Read the docsChoose Pi, Claude Code, Codex, or OpenCode. Keep the same API for agents and runs.
Read the docsRecover interrupted runs with saved conversation, files, and recorded tool results.
Read the docsManage multiple agents, version their definitions, and inspect every run from one console.
Read the docsCombine tools, decisions, and agent steps into workflows you can inspect, test, and reuse.
Read the docsConnect built-in tools and remote MCP servers, with explicit tool access for each agent.
Read the docsGive each run its own files. Upload inputs, inspect outputs, and continue with saved work.
Read the docsRun the Apache-2.0 platform on your own machine or server with your own model keys.
Read the docs05 AGENT MANAGEMENT
See what your agents are doing, find the runs that need attention, and inspect their results through one console and API.
Manage instructions, tools, and the revision each agent runs.
Monitor progress, respond to requests for input, and inspect files.
Review what an agent learned and the context available to its next run.
PLATFORM COMPARISON
Choose your harness. Own your infrastructure. Turn repeated work into reusable skills and tested workflows.
Scroll to compare platforms
| What you get | Open sourceAgentRun | AnthropicClaude Managed Agents | OpenAIAgents API | Google CloudGemini Enterprise Agent Platform |
|---|---|---|---|---|
| Open source & self-hostableFull platform, including the console | Apache 2.0 | Managed service | Managed service | Managed service |
| One API across harnessesChoose how your agents run | Pi · Claude Code Codex · OpenCode |
Claude only | Codex only | Custom integration |
| Learns skills & workflowsFrom completed runs | Built-in, evaluated learning | Memory learning Preview |
Not documented | Skill optimization Experimental |
| Durable executionRecover interrupted work | Built-in recovery | Durable sessions | Durable sessions | Opt-in resume |
| Run multiple agentsManage concurrent work | Shared API & console | Agent teams | Parallel subagents | Multi-agent workflows |
06 DEPLOYMENT
Learning, recovery, and the console are all open source. Run AgentRun with your own API keys, or choose a hosted deployment.
Built by the team behind Grep AI, whose platform powers business process agents at Worldpay, IG.com, Citizens, and Airwallex. Self-host AgentRun with your own keys, or let us host it on AgentRun Cloud.
FAQ
How learning works, where the savings come from, and what stays under your control.
AgentRun is the platform around your chosen harness. Define agents, run them through a common API, and manage their revisions, run history, recovery, and learning in one place. The harness still handles the agent’s reasoning and tool use.
AgentRun is open source under Apache-2.0, built by the team behind Grep. Learning, recovery, and the console are included. You can self-host with your own model API keys; model and infrastructure costs are yours. Grep is our managed platform for business agents. AgentRun Cloud is our hosted AgentRun offering, and is optional when you self-host.
When learning is enabled, the agent reflects on its runs and proposes notes, reusable skills, and workflow drafts. Accepted changes are versioned and available to later runs, so repeated steps can be reused instead of planned again. This updates the agent’s saved knowledge and procedures, not the model’s weights.
An agent can spend tokens rediscovering an API, planning the same request, or deciding how to validate a result. Reusing a skill or workflow can skip that repeated reasoning. The agent still uses models and tools where needed. Potential savings come from reducing repeated work.
Savings depend on how much work repeats. The launch post reported a 90% cost reduction for one compliance workload. Results vary, and reflection and grading also add cost. Measure total spend and answer quality on your own workload, including the cost of learning.
You define the threshold and the fallback in your workflow. Uncertain results can go to an agent for further investigation or trigger escalation for review. A confidence score is a routing signal, not a guarantee of accuracy. Choose thresholds using evaluated examples and the consequences of getting the decision wrong.
No. Jev is an optional integration for focused decisions in workflows you author, such as choosing a category or returning a score. Agents and self-learning work without it. Automatically learned workflows currently use supported model and tool steps; they do not automatically turn into Jev decisions.
No. Keep open-ended tasks agentic and make repeatable steps reusable. Workflows can include agent investigation at defined points, so you can automate routine paths while deciding how exceptions should be handled. You control where a workflow continues, retries, or asks for help.
Proposals pass structural checks and an AI grader before they can be reused. Changes that widen trust, loosen checks, or direct money or data require owner approval. You can inspect changes, edit notes, or retire learned material. These checks help filter proposals; you still need to evaluate results on your tasks.
Pi, Claude Code through the Claude Agent SDK, Codex, and OpenCode. Choose a harness in your AgentRun agent definition while keeping shared run management and learning. Each harness needs its own configuration, and available models and tools can differ.
Yes. Self-host the open-source platform locally or on your own server and bring your model API keys. Agent definitions, runs, and learned material live in your configured data directory. Model calls and hosted browser sessions still go to the providers you configure.