As AI agents become more capable, traditional software testing becomes obsolete for agent testing.
Software used to be deterministic enough to test with expected inputs and outputs. Given any input, the developer would know the intended output and write tests that matched it. Agents are different. They are non-deterministic and operate with a much higher degree of freedom.
That degree of freedom is what makes agents useful. Their real value comes from taking actions in the world: calling APIs, reading and writing to other software, reacting to events, handling permissions, retrying failed calls, and navigating the operational reality of software. This is also what makes them fundamentally different to test.
For agents that summarize or answer solely from memory, prompt evals may be enough. But the moment an agent starts using tools, the testing surface moves outside the model.
This shift is already visible in how agents are evaluated and deployed. Benchmarks like WebArena and WorkArena move evaluation into realistic, executable environments because single-turn tasks miss failures that only appear during long-horizon interaction with software. At the same time, standards like robots.txt and MCP are making more software directly actionable by agents. The trend is clear: agents are getting access to more tools and more freedom to decide how to use them.
As agents become more capable, we will continue to give them more freedom, more important tasks, and access to more systems of record. Better agents do not shrink the testing problem. They expand the blast radius of what we are willing to trust them with.
That's not solved by writing more test cases. It's solved by giving agents a simulation of the real world.
Real-world sandboxes
Arga is built around the belief that agents cannot be tested using existing testing frameworks. So we built real-world sandboxes, built on high-fidelity twins of the external software these agents interact with. Teams test against our twins through API, CLI, and MCP interfaces in an environment that reproduces how the real service functions with 100% fidelity, instead of testing against shallow mocks or in live production.
These interfaces change the state of the software, so we designed our sandboxes to capture the internal state of the SaaS. This way, customers have full transparency into how the agents change the state of the SaaS it integrates with. Customers use Arga in place of the actual services because we preserve the nuances that change agent behavior: authentication, authorization, permissions, mutable resources, webhooks, timing, failures and retries, while solving issues like rate limits, state accumulation, and the risk of testing against live production systems.
We can now clone any SaaS in under 12 hours with 100% fidelity in backend functionality and behavior, and customers have already run more than 100,000 twin instances in the past 16 weeks.
Today, we're announcing our $10 million seed round led by General Catalyst, joined by BoxGroup, Emergence, Gradient, and SV Angel.
From tests to environments
Most products mock API endpoints only, providing a stateless system. We decided to replicate the internal state of the services along with the CLI/MCP support that agents prefer. We also replicate permissions (every call needs to be authenticated by a valid token), webhooks (most agent actions are async), and per-app tiered access (e.g. Slack's free and paid tiers).
Though our twins are separately hosted, Arga provides a simple way to produce “scenarios”, which are multi-app shared states that are deterministic across runs. For example, a customer can build an e-commerce support system scenario within our environments, which could contain Slack, Stripe, and Jira twins with the same user data and synced orders.
To effectively evaluate multi-app agent behaviour, the environment has to be unified. Testing one SaaS twin at a time neglects both the sequential and in-parallel multi-app workflows that agents actually execute, which is where agents tend to fail.
That behavior is what we measure in ArgaBench, our multi-app agent benchmark powered by Arga twins. We found that frontier models, like Anthropic's Claude Fable 5 and OpenAI's GPT 5.6 Sol, could not reliably perform multi-app cross-checks despite completing most of the task. In one example, both failed a task that required changing the price of a product in Stripe and cross-checking its metadata in Notion without explicit instruction. We will be releasing the full benchmark and our research findings shortly.
There's still a long way to go before agents can reliably work on long-horizon tasks across different software systems. Arga is building the validation infrastructure to make robust general-use agents possible beyond just partial workflows.
Building for what comes next
Today, we ask how to test an agent that can choose among a handful of known tools. Tomorrow, an agent may discover a public API, understand its schema, sign up for it, call it, combine it with other APIs, and act across systems that the developer never expected.
We're using this funding to accelerate R&D on a harness that generates high-fidelity SaaS twins in minutes, rather than hours. As agents gain the ability to discover and call any public API, manually building an environment for every tool stops scaling; the testing infrastructure has to generate the world around the agent as the agent discovers them.
We're also building the eval platform needed to make Arga a complete environment for testing and training agents. Since we own the states of the services, we can provide the traces, anomalies, and errors agents produce while interacting with our twins. This enables users to quickly identify what needs to be improved and how to do so.
Agent failures shouldn't be discovered in production. We're hiring across engineering, research, product, and GTM. If you want to help us build the infrastructure for autonomous software, please get in touch.
