Show HN: AgentRun – open-source, Self-improving Managed Agents

Run smarter agents. Use fewer tokens. Quickstart · Tour · Templates · Deploy · Docs AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a control plane on top of your favorite agent harness. Your agents become smarter, more fault tolerant and use fewer tokens with every run. An agent's Learning tab: what it kept, and what changed since. Demo data from the console's recorded fixtures. Why AgentRun Agents are great at figuring things out. The problem is they figure out the same things over and over. Give an agent a job it has done a hundred times and it rediscovers the same API, rereads the same docs and rebuilds the same plan, and you pay for every token of it. Bring your agent on the harness it runs best on: Claude Code, Codex, OpenCode or pi. AgentRun does everything around it: It learns the work. After each run, the agent keeps what will help next time: a note, a skill, or a workflow that does the job without the loop. The next run starts from there. It never loses a run. Every run lives in one store. Kill the server mid-run, start it again, and the run carries on. Give each agent the computer the job needs: a sandbox, a Linux desktop, an Android phone or a browser. You stay in control. Approvals, spend caps and one console for every agent: what needs you, what failed, what's running and what it cost. You don't build the plumbing: provider integrations, recovery, run tracking and learning are all here. Run it on your laptop with one command, in one container, or as a server with runners. Apache-2.0. Start in three steps You need Node 24.22.3 or newer, on macOS or Linux. Start it. npx @parcha/agentrun It starts the server and one runner on port 7340 (or the next free one), keeps everything in ~/.agentrun , and opens the console in your browser. Add one model key. In the console, set a password, then add a key under Settings → Model keys . One OPENROUTER_API_KEY gives every harness a model. An Anthropic key runs pi and Claude Code; an OpenAI key runs pi, Codex and OpenCode. Run your first agent. Open Templates , apply KYB due diligence , and start a run with a company's name and website. It needs nothing but your model key. When it finishes, the run's Report tab has a due diligence report with a verdict and every claim cited. Then open the agent's Learning tab to see what it kept for next time. Rather have your coding agent do it? Tell it: Read agentrun.ai/SKILL.md and set up AgentRun for me . Docker, sandboxes and running it on a server If Docker is running on your machine, new agents get a Docker sandbox with a shell. Its image builds on first use, which takes a few minutes, and the console says when it's ready. Without Docker, agents still read and write files, but get no shell. Want your own server with a URL? Deploy it to Render in one click. Take the tour Workflows that make the call. A step can ask a fast typed question, see how sure the answer is, and pick a route. Here the model leans approve at 0.61, below the workflow's 0.75 bar, so the case goes to review. Every agent in one place. Mission Control opens first: what needs you, what failed, what's running and what it cost, by day, by harness and by tool. Every agent is an API. Start a run from the Playground, then copy the same request into your code. You stay in control. An agent can stop and ask you, and the run waits until you answer. Agents that learn the work Turn it on with "learning": true in an agent's definition. At the end of every run, the agent gets one more turn to say what it would keep. AgentRun checks it, grades it, and commits the keepers to the agent's own git folder. The next run starts from there. flowchart LR start["Run starts from
the agent's main"] --> work["Run does the job"] work --> propose["Last turn proposes
notes, a skill, a workflow"] propose --> check["Code checks,
then one grader"] check -->|kept| commit["Commit to main"] commit --> start Loading Notes are short markdown files, one fact each, in Claude Code's memory format. Skills are how to do a job again, and only a run that finished the job can write one. Learned workflows run as one tool call on any harness, under the run's own cap and tool permissions. Once a learned skill has served 3 runs, the next run is asked for that job as a workflow draft, and a draft is dry-run before it's kept: no model is asked and no tool runs. The agent's Learning tab shows every note, skill and workflow and the log of changes, and each run shows which notes it was given and opened. Retire anything there, or with npx @parcha/agentrun learning retire and the note's ETag. Git keeps the history, so a retired note can come back. What gets kept, and what gets dropped Each agent has a learning folder: plain git with one branch, main . A run reads the index of active notes in its instructions and gets the learned skills beside its own. Code checks every proposal first. An item that breaks a rule of its own (a size or count limit, its name, its shape) is left out and the rest goes on. A secret or a hidden character anywhere in the answer, a file outside the folder, a deletion or a full index drops the whole answer, since no item of it can be trusted. Then one grader judges what it says, and AgentRun commits what passes. A risky rule waits for your OK. A rule the run found in a page or a pasted email, or a note that holds an account number, is dropped. Once an agent's notes outgrow the learning budget, each run gets the ones that bear on its first message, whole, and a line for each of the rest. A run that only ran a learned workflow isn't asked what to keep. Workflows A lot of agents don't need to be agents. Write repeatable work as a typed workflow: tool calls, model steps and fast typed decisions (yes or no, pick one, a score, each with its confidence), with an agent to fall back on when a case is unclear. AgentRun runs it as an agent's revision, under the agent's tool permissions and a cap like any run, and a trigger can start one. An illustration of the control flow in examples/support-answer.mjs , not a recording of a model run. Watch any workflow run node by node, pause it and resume it, and read every decision and why it was made: What a workflow looks like A workflow is a JSON document of typed steps: { "v" : 2 , "name" : " read-site " , "schemas" : { "In" : { "type" : " object " , "required" : [ " website " ], "properties" : { "website" : { "type" : " string " } } }, "Page" : { "type" : " object " , "required" : [ " ok " ], "properties" : { "ok" : { "type" : " boolean " } } } }, "input" : { "schemaId" : " In " }, "output" : { "schemaId" : " Page " , "path" : " home " }, "root" : { "node" : " chain " , "steps" : [ { "node" : " call " , "label" : " Read the home page " , "via" : " tool " , "tool" : " web_fetch " , "args" : { "url" : " {website} " }, "out" : " Page " , "as" : " home " , "deadline_s" : 60 } ] } } Steps can call tools, run a model, ask a fast typed question, branch on the answer, map over a list in parallel, loop a bounded number of times, call other workflows, or hand the hard case to an agent. Save one as an agent's workflow field; npx @parcha/agentrun workflows validate checks it first. The workflow language also runs on its own inside your app, with a TypeScript builder . Runs that survive Every agent, revision, run and step lives in one store. Stop the server mid-run and start it again, and the run carries on. With several runners, another runner picks up a dead runner's runs once their 30-second lease runs out. A finished step is never run again; a write a crash cut off mid-call is marked interrupted rather than retried, so you can check it. You