Give coding agents tools to prove the result.

A completed response is not completed software. Neroli keeps repository checks, browsers, simulators, command output, and the final diff with the isolated task so you can review what actually works.

Request access Read the docs

Verification tools support review; they do not guarantee that a change is correct or safe to merge.

Why Neroli

Make validation part of the agent workflow.

Verification is strongest when the agent can run the product, the evidence belongs to the exact session, and a developer can still inspect the result.

Run the repository's real checks

Keep builds, tests, linters, and other project commands in the session instead of treating a finished agent response as proof.

Exercise web changes in a browser

Open a browser for the task, inspect rendered behavior, interact with the page, and keep the verification surface attached to the workspace.

Drive the session's iOS Simulator

For mobile work, build through repository commands and use the workspace's dedicated simulator to inspect and exercise the app.

Compare the code that changed

Review the session diff alongside command results and product behavior before deciding whether the implementation is ready.

Keep evidence with the task

Terminals, browser state, simulator state, output, screenshots, and artifacts stay associated with the session that produced them.

Preserve the human decision

Agents can run tools and collect evidence, but you still control approvals, review the result, and decide what merges.

The workflow

Set criteria, run checks, exercise the product, review.

Neroli connects automated checks and interactive product surfaces to the same isolated workspace where the code changed.

  1. 1

    Define what success means

    Give the coding agent concrete acceptance criteria and identify the repository checks or product surfaces that can demonstrate the behavior.

  2. 2

    Run builds and automated checks

    Use the project's own commands inside the isolated session so failures point back to the exact branch and environment under review.

  3. 3

    Exercise the real interface

    Open the session browser or iOS Simulator when the change needs interactive proof that static checks cannot provide.

  4. 4

    Review the evidence and diff

    Inspect what passed, what remains uncertain, and exactly which files changed before merging or asking the agent to continue.

Commands

Verification starts with the repository contract.

Neroli does not invent a universal test suite. It runs the builds, tests, linters, smoke checks, and validation commands the project defines.

  • Repository-owned check commands
  • Terminal output attached to the session
  • Failures visible before review completes

Product surfaces

Use the interface the change actually affects.

A passing type check cannot prove a layout or interaction. Browser and simulator surfaces let the agent and reviewer exercise the working product.

  • Browser navigation and interaction
  • Dedicated iOS Simulator workflow
  • Screenshots and artifacts when useful

Review

Proof informs the merge; it does not replace judgment.

Verification reduces ambiguity by keeping code, tool output, and observed behavior together. The developer still decides whether the evidence is sufficient.

  • Diff and evidence in one task context
  • Manual follow-up when results are incomplete
  • A clear decision point before merge

Questions

What developers ask.

How can coding agents verify AI-generated code in Neroli?

They can run the repository's builds and tests, exercise web work in a browser, use the workspace's iOS Simulator for mobile work, and present the resulting diff and evidence for review.

Does Neroli decide whether code is correct?

No. Neroli gives coding agents and developers a consistent place to run checks and inspect behavior. Correctness still depends on relevant acceptance criteria, good tests, careful review, and the limits of the systems being exercised.

Can an agent interact with a browser?

Yes. Neroli provides workspace browser tooling for opening pages, inspecting the interface, interacting with controls, and collecting verification evidence for web tasks.

Can an agent test an iOS app?

Yes. For supported iOS workflows, the agent can use the Neroli workspace's dedicated simulator to install, launch, inspect, and interact with a development build created through repository commands.

Does verification stay isolated per coding agent task?

The session keeps its branch, worktree, panes, command output, browser or simulator surface, and changes attached to that task. Any shared external dependency still needs project-appropriate coordination.

Field guide

Apply the evidence model to an Xcode software factory.

Connect tests and visual proof to the exact Mac app build, then carry that evidence into review and merge.

Read the Xcode software factory guide

Keep exploring

Isolated workspaces Keep each task's code, environment, and tools together.
Parallel coding agents Give every concurrent task the same deliberate review path.
Coding agent automations Turn repeatable checks and agent workflows into visible runs.

Neroli beta

One Mac workspace for all your coding agents.

Tell us how you work today and which provider you want to run first.

Request access