Introducing AgentRun: Run smarter agents. Use fewer tokens.

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 will rediscover the same API, reread the same docs and rebuild the same plan, and you pay for every token of it.

AgentRun fixes that. It's 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: pi (@pidotdev), our default, Claude Code, Codex, OpenCode, or any harness that speaks the Agent Client Protocol. It gives them whatever computer the job needs, too. Your agents get smarter and more fault tolerant, and use fewer tokens with every run. AgentRun handles the plumbing: provider integrations, recovery, run tracking and learning. You don't have to build any of it.

Your agents also get thousands of tools through @MonidHQ and @composio, and your own APIs and MCP servers through a custom tool proxy. Install it with one command, deploy it to Render in one click, or start right now at console.agentrun.ai.

How we got here

A few weeks ago we open-sourced the most valuable parts of our harness as pi extensions. We found that for most purposes, pi-durable plus our extensions was enough: a browser of its own, computer vision, whatever computer the job needs, the ability to improve itself, and Mission Control. Everyone asked the same thing: do I need to switch harnesses to use this? We had the same need. We also run the Claude Agent SDK and Codex internally, and labs keep telling us their models are post-trained on their native harnesses, so keeping each model on its own harness could make cheaper models like Luna, Terra and Sonnet a lot more efficient. We want that, and we still want the superpowers. That's AgentRun.

Three things I'm excited about

1. Learn the work once

We started talking about self-improving agents back when we introduced the AgentRun harness. Our focus has been repetitive knowledge work: things companies do thousands, even millions of times with different inputs, like checking a document against a list of specs, business due diligence or vendor onboarding. Someone sits down and follows the same procedure over and over.

Harnesses out of the box aren't great at this. They're built to loop until they solve a problem, not to get efficient at solving the same one. It's like handing Einstein a stack of paperwork: he'll get it done, but he'll think hard about every form, every time. With learning turned on, an agent looks back when it finishes a run and leaves notes for next time: hints, what worked, what didn't, how to do the job better. Over time the same agent starts writing a general solution to the problem as a workflow in our workflow DSL, and later runs reuse it instead of planning everything again.

What we found is that most of these problems don't need an agent at all. A simple workflow, with @typesafeai's Jev or @p0's Decisions API making the judgment calls, is enough. In some cases you need a small agent, like a web researcher, for one step. I've written about this a few times recently.

And now agents can be born as workflows. A workflow can do what an agent does: make a decision, classify something, pick between options, run an agent or another workflow. It just doesn't need a loop to do it.

With web-grounded decisions like @p0's, workflows can now check facts on the web without a full agent. That opens up a lot of work that used to need an agent, at a fraction of the cost.

The platform includes a visualizer: you can start any workflow, watch it run node by node, pause it, resume it and inspect every decision. And anything you build is instantly an API. Tell your coding agent to build an agent that automates a task, and you can call it from your pipelines, your product or your internal tools right away.

2. Choose your computer, keep your progress

There are a lot of sandbox and computer companies out there, solving similar problems in different ways. Depending on your use case, you may need a simple sandbox, a VM with GPUs, a phone, or a fully fledged Linux, Mac or Windows computer. But the agent doesn't need to live inside any of them. Running the whole agent in there is inefficient and expensive, and yet that's what most people do today.

We separate the brain from the hands. The agent is just a loop, and it runs in a cheap Node runner that holds hundreds of loops at once. It uses a computer only while a tool call needs one, so an expensive GPU only bills while it's doing work. At scale this saves a lot of money.

We're big believers that the agent is its workspace: the state it operates in. In our case that workspace lives in Archil (@archildata), and the agent can use it from any computer it runs a tool on.

Think of it as a train network. The agent's run is a route, and each leg can take a different train: a tiny local for reading a few files, a commuter line for running the tests, a regional for driving a phone, and a bullet train when it needs a GPU. The agent picks the train for each leg and gets off when the leg is done.

A managed agent platform that hands you one basic sandbox doesn't let you change it while a job runs. In AgentRun the agent can switch computers between tool calls, and if you want, a classifier can pick the right one for each call.

We're building our own computers: Linux sandboxes in several sizes, full Omarchy desktops, and persistent Android phones. They keep their state between uses, and you can watch any of them live and take over. AgentRun also drives sandboxes from @daytonaio and @modal, GPU clusters on @modal, iPhones from Phone harness, and Mac and Windows computers through @Orgo.

We also spend a lot of time evaluating our skills, prompts and computer-use technology so these agents are the best out there at driving computers.

Built on pi-durable and durable-harness

Every harness on AgentRun is durable. With @pidotdev's pi we use pi-durable. For the other harnesses we use durable-harness, which @vercel open-sourced and we adopted into our repo. Workflows are durable too. If a run stops halfway, it doesn't start over: its conversation, files and run state are saved, and it picks up right where it left off. Thanks to both teams.

3. Every agent in one place

Mission Control is a bird's-eye view of your fleet: what your agents cost, how many tokens they use, how often they succeed, and which harness does best on what. We use a version of it internally to watch the hundreds of agents deployed across the company and decide where to improve. It's all in the API too, so an agent can watch the fleet for you, start learning on the agents that struggle, and send you reports or alerts.

Templates

We're launching with five templates: code review, release notes on GitHub, KYB due diligence, an inbound lead researcher, and a weekly competitor monitor. Install one and make it yours. A marketplace is coming soon.

One of the templates we're releasing is code review. Paying $1 a review gets insane with how many reviews we run, so we built our own. It runs on @particle_api's Particle-1, works on any repo, learns yours through self-improvement, and takes specs for different parts of it. A review costs us 2 to 3 cents. We're still iterating on quality, but here's how it compares so far.

We'll also release templates for workflows that people run as agents today, and templates with learning already baked in: run an agent thousands of times with learning on, then turn it into a template and share it on the marketplace. That's more than sharing skills, tools and prompts. It's the whole toolkit an agent needs to run efficiently out of the box.

Triggers and schedules

Your agents shouldn't sit around waiting for someone to click run. Put them on loops, like the ones we built for Grep: every hour, every morning, every Monday, whatever cadence the work needs. Or wake them up the moment something happens: a webhook from your own systems, a pull request on GitHub, a message in Slack, or a Parallel monitor that watches the web for what you care about, like a lawsuit, a funding round or a new regulation, and fires when it shows up. And through Composio triggers, events from the rest of your apps can start an agent too. Define the work once, and AgentRun keeps it running.

Try it

AgentRun is available today as an open-source alpha. Three ways to start:

On your machine:

npx @parcha/agentrun

Or just tell your coding agent:

Read agentrun.ai/SKILL.md and set up AgentRun for me.

• On your own server: hit the @render deploy button in the README, paste your @openrouter key, and you have your own AgentRun server with a URL, for about $27.50 a month.
• Hosted: sign in at console.agentrun.ai.

All you need is an OpenRouter key, which covers the models for every harness and the decision models workflows use. Use a key with a credit limit and an expiration date, in case it ever leaks.

The hosted version adds access controls, SSO and swarms. Swarms work like they do in Grep: hand a team of agents a whole backlog, and a coordinator splits the work across specialists, then pulls their findings back together. Thousands of agents, one result your team can use. And if you're an enterprise that wants control over where your agents run, where their workspaces live and even where the control plane lives, we can run AgentRun on your infrastructure, with your own agents and your own cluster. Talk to us.

Give AgentRun a try, or have your coding agent try it. Send me feedback. I'm happy to sit down with you and get you running, and I can't wait to see what you build with it.