GREP.AI has open-sourced AgentRun and expanded it into a managed agents platform. Through ACP, it supports runtimes such as Claude Agents and Codex, with execution environments—not another layer of model abstraction—as its primary focus.
AgentRun Goes Open Source as Agents Bring Their Runtimes
Agent platforms have traditionally bundled models, tools, and workflows into a single product. Switching models or Agent harnesses often means rewriting code, reconfiguring environments, and losing access to debugging history in the process.
GREP.AI (YC F26) is taking the opposite approach. It has open-sourced AgentRun and turned it into a full managed agents platform. Its README states:
We (GREP.AI, YC F26) are open-sourcing AgentRun and turning it into a full managed agents platform.
The company is positioning itself as a control layer above models and runtimes.
From an Internal Framework to an Open Platform
AgentRun did not begin as a general-purpose cloud platform. It started as the Agent harness used internally by GREP.AI.
That sequence matters. GREP.AI first made its own internal workloads work, then opened up the execution environment, tool integrations, behavioral analytics, and service hosting. The platform now provides a complete execution stack:
- Web-grounded workflows
- Multiple sandboxes and computer environments
- Thousands of tools and integrations
- Agent behavior analytics and self-improvement capabilities
AgentRun also supports self-hosting. Deployment and usage instructions are available in the GitHub README.
This creates two product options:
- Managed version. Users do not need to maintain containers, browsers, credentials, or runtime environments themselves.
- Self-hosted version. Users retain control over their data and infrastructure while continuing to use AgentRun's core capabilities.
This split is more practical than offering only a fully managed service. An Agent's tool activity, tool selections, and generated files may all involve enterprise data. Whether to use the cloud cannot be decided solely on the basis of convenience.
ACP Is the Linchpin of the Compatibility Layer
AgentRun's central proposition can be summarized as bring your own agent.
The README is explicit:
AgentRun works with Pi, Claude Agents, Codex, OpenCode, and any other harness that supports ACP.
ACP serves as an adapter layer. AgentRun does not require every team to standardize on one harness; any harness that supports ACP can connect.
This directly affects migration costs.
Imagine a team starting with Claude Agents for coding tasks, then finding that a particular batch workload is better suited to Codex or wanting to test OpenCode. Under the old approach, teams often had to rebuild tool invocation, state management, and sandbox configuration. With ACP, the execution protocol can at least remain consistent.
However, ACP compatibility does not mean models, context management, prompt strategies, or tool behavior will be identical.
Different harnesses may still handle task decomposition, error recovery, tool selection, and context compression differently. AgentRun solves the problem of connecting and running Agents, not whether different Agents will produce equivalent results.
The Runtime Matters More Than the Model
A large language model is only one layer of an Agent. The components that actually perform tasks are browsers, code sandboxes, file systems, network access, API credentials, and external tools.
This is why AgentRun focuses on managed agents.
It provides Web-grounded workflows that allow Agents to complete tasks based on live web pages. The platform also offers multiple sandboxes and computer environments, along with thousands of tools and integrations. For enterprise users, these capabilities are closer to real costs and operational requirements than another wrapper around a model API.
Deploying a functional Agent demo is usually not difficult. Maintaining reliable behavior across the following details is:
- How browser sessions are isolated
- Which container executes code
- Where API keys are stored
- How tasks recover after a timeout
- How failed external pages are retried
- Which files and logs a task produces
- Whether one task can contaminate another
These engineering capabilities are what a managed platform truly sells.
From a product perspective, this also explains AgentRun's emphasis on bringing your own Agent. Models remain replaceable. Claude, Codex, or another LLM can serve as the reasoning engine, while the platform retains control over the execution environment, permission boundaries, and observability data.
Self-Improvement Requires Observability
AgentRun lists two capabilities as core features:
- Self-improving agents
- Detailed analytics on how your agents behave
They need to be considered together.
Without records of trajectories, tool calls, and environment state, self-improvement is largely a matter of changing prompts and guessing where the problem occurred. An Agent task can fail because of a model decision, but also because of a browser timeout, expired credentials, a change in a tool's response format, or contaminated sandbox state.
If a system sees only the final failure, it lacks enough information to determine whether it should change the model, modify the prompt, or repair a tool.
Fine-grained behavioral analytics should, at minimum, record:
- Which tool the Agent selected at each step.
- Which parameters the tool received.
- What the response and environment state looked like.
- Why the Agent continued, retried, or gave up.
- How the final result differed from the intended objective.
With these trajectories, self-improvement can move beyond guessing prompts from failed samples and toward modifying the specific stage where a failure occurred.
Behavioral analytics also introduces privacy and security concerns. Agent trajectories may contain user inputs, web content, file fragments, and credential-related context. Platforms must define data retention periods, redaction practices, and access controls. Otherwise, stronger observability expands the exposure surface as well.
Agent Platforms Do Not Have to Be Tied to Models
AgentRun's most important contribution is not creating another Claude or Codex. It is defining clear boundaries among models, harnesses, and execution environments.
Model capabilities continue to change. Closed API pricing, context windows, and tool protocols shift, while new open-source models appear regularly. When application logic is deeply coupled to a specific Agent runtime, every upgrade becomes a migration project.
ACP provides a replaceable interface, while AgentRun adds execution and observability infrastructure. Together, they make the platform resemble an operating system or control plane for Agents rather than an appendage to one model.
This also changes the tradeoffs between managed and self-hosted deployments.
The managed version suits teams with high task volumes, complex execution environments, and little interest in maintaining infrastructure. Self-hosting suits teams with sensitive data, existing Kubernetes capabilities, or a need to modify execution environments deeply.
Self-hosting, however, is not free. Someone still has to own container images, browsers, credential management, and log storage.
Whether AgentRun can actually reduce migration costs cannot be determined from its compatibility list alone. The breadth of real ACP support, functional differences among harnesses, and the managed platform's depth of support for each runtime all require validation in production projects.
Editorial Perspective
AgentRun matters not because it open-sourced an Agent framework, but because it shifts the competitive focus from models to runtimes. Models can be replaced and tools can change, but the expensive parts are often execution environments, state management, and failure tracing. If ACP is stable enough, teams can reduce migration work. If AgentRun provides consistent tool semantics and observability data, switching between managed and self-hosted deployments becomes easier.
The more important question is not how many models AgentRun supports, but whether it can let different harnesses run fairly within a shared observability and evaluation system. That differs from comparing model leaderboards, context windows, or Agent demo success rates. The unit of evaluation is now the complete execution chain.
It is still too early to draw a conclusion. The README leaves several key uncertainties unresolved: which real capabilities ACP covers, whether Claude Agents, Codex, and OpenCode behave equivalently after integration, and whether fine-grained analytics introduces significant costs and data risks. Self-improvement requires validation standards in particular. One accidental success does not prove that a system has learned a reusable capability.