Reticle

Inspiration

AI coding agents are getting remarkably good at writing code. The problem is what happens after they write it.

An agent can change five files, run a command, see a successful response, and decide the task is complete. But the application can still be broken.

We built Reticle around a simple idea: agents shouldn't be trusted to decide whether their own work is correct. They should have proof.

WebMCP made this idea even more interesting. If agents are going to operate real web applications, the web itself needs a better interface for agents to interact with and verify what is actually happening.

What it does

Reticle is an open-source verification layer for coding agents.

It lets an agent test a real running application and verify behavior across the stack, including network requests, console errors, application state, routing, and persistence.

Instead of returning something vague like “the page looks correct,” Reticle produces deterministic evidence and a clear PASS/FAIL result that the agent can use to decide what to do next.

For the WebMCP challenge, we extended this idea to web workflows. Reticle gives agents structured capabilities for interacting with and verifying applications, reducing their dependence on screenshots, DOM guessing, and brittle browser automation.

The goal is simple: turn “I think it works” into “here's the proof.”

How we built it

We built Reticle as an open-source developer tool that sits between the coding agent and the running application.

The agent can invoke Reticle through MCP, while Reticle connects to the actual application and collects evidence from the runtime. We designed the verification layer to be as deterministic as possible rather than asking another LLM to judge whether the application is correct.

For the WebMCP challenge, we focused on exposing these capabilities through the web so an agent can discover what it can do, execute real workflows, and verify the resulting state.

The architecture is intentionally modular: agents handle reasoning and implementation, while Reticle handles observation and verification.

Challenges we ran into

The hardest part was defining what “correct” actually means.

Checking whether a button exists is easy. Proving that clicking it triggered the correct API call, changed the correct application state, persisted the result, and left the application without errors is much harder.

We also had to deal with the reality of modern web applications. Framework state, asynchronous requests, client-side routing, browser state, and persistence all behave differently, and a useful verification system has to observe more than just what is visible on screen.

Another challenge was keeping Reticle useful to agents rather than just humans. The output has to be structured enough for an agent to understand what failed and what it should investigate next.

Accomplishments that we're proud of

We're proud that Reticle is not just a conceptual WebMCP demo.

It is an open-source verification system that can already be used with real coding agents and real applications.

We have built a workflow where an agent can make a change, run Reticle, receive concrete evidence about what happened, and use that evidence to continue debugging.

Most importantly, we think we are attacking a problem that will become more important as coding agents become more autonomous: verification is becoming as important as generation.

What we learned

We learned that giving an agent more tools isn't necessarily enough.

The quality of an agent's output depends heavily on the quality of the feedback loop around it. If the agent cannot reliably observe the consequences of its actions, it is forced to guess.

WebMCP reinforced another belief for us: the web should not only be designed for humans. As agents become first-class users of software, websites need machine-readable capabilities and predictable ways for agents to interact with them.

The interesting future isn't agents replacing interfaces. It is interfaces becoming understandable to both humans and agents.

What's next for Reticle

We're working toward making Reticle a verification protocol and infrastructure layer for coding agents.

Today, agents can generate code and run tests. We want them to be able to prove that real applications work.

That means expanding verification beyond individual checks into complete real-world workflows, making the protocol easier for agents and developers to adopt, and building a larger ecosystem around standardized verification.

Our long-term goal is straightforward:

Agents should not ship code because they believe it works. They should ship it because they can prove it works.