Company
Independent oversight for AI software agents.
Software is increasingly planned, written, and repaired by agents. Vraelis is the independent layer that checks the result against a guarantee a person approved, so companies can hand agents real work without giving up control.
Why we exist
The builder can no longer be the only judge.
For most of software's history, the same people who wrote a system also reviewed it, tested it, and decided it was ready. That worked because the work moved at human speed, and human judgment was always in the loop.
Agents changed the ratio. They now plan, build, and repair systems faster than the people nominally reviewing them can keep up, and the agent doing the work is still the one reporting that it is done. Speed went up. Independent judgment did not.
Vraelis exists to restore that judgment as a separate function. Not to slow agents down, but to make their completions mean something: a claim that has been checked against the running software by something other than the agent that produced it.
Three acts
How the work is changing, and what has to follow it.
The story of software is a story about where judgment lives. It has moved, and oversight has to move with it.
Humans owned the judgment.
People wrote, reviewed, tested, and shipped. Shipping something you had not checked was a deliberate choice, because the work and the judgment about it lived in the same hands.
Agents outran their reviewers.
Agents now plan, build, and repair systems faster than anyone reviewing them, and the builder still grades its own work. Vraelis puts an independent check back where that judgment used to be.
Oversight follows the autonomy.
As agents take on more responsibility across the stack, independent oversight follows them everywhere, so autonomy is earned against evidence and contracts the moment the record slips.
Who it is for
One outcome that cannot be allowed to break, and an agent that keeps touching it.
Companies whose production software is now partly written by agents
The work arrives faster than anyone can review it by hand, and the thing that wrote it is also the thing reporting it is done.
Where at least one outcome is not allowed to quietly break
The upgrade that has to grant access, the deactivation that has to remove it everywhere, the export that has to contain one tenant's records and no one else's.
And where someone is accountable when it does
A person who would have to answer for the failure, and who currently has the agent's own word that it will not happen.
Anyone who wants the agent watched while it works
A check begins when work is claimed complete. Reading an agent's activity as it happens is direction, and is not built.
Anyone who wants a test suite written for them
Vraelis holds one business sentence outside the code and checks the deployed result against it. It does not author or maintain your tests.
Anyone who needs a native mobile or desktop application covered
The boundary today is what a real browser and an HTTP client can observe from outside.
How this is different
Four things it is not, and what it does instead.
Stated against the categories a reader is already paying for. No competitor is named and none is characterised, because a claim about somebody else's software is a claim this company cannot show evidence for.
It is not the agent's own report
The system that wrote the work does not get to be the authority on whether it worked. The check is run by something else, against the deployed result, and the separation is structural rather than a matter of prompting.
It is not a test suite
A suite is written alongside the code, often by the same process, and passes in a pipeline against mocks. Vraelis holds one sentence in business language outside the code and drives the running deployment against it.
It is not monitoring
Monitoring reports that something broke once your users have already found it. This is a decision made before that, on the deployment you are about to trust.
It refuses rather than guesses
When no check could prove the claim, the answer is Blocked and nothing is charged. A verification tool that always returns an answer is a verification tool whose answers cannot be worth much.
Three times this was tested by somebody else, with sources and with the cases where an independent check would have done nothing: what happened in public.
Product direction
One capability today, one system over time.
Vraelis starts from a working verification engine and expands outward into full oversight. We ship what is real and label the rest as direction, and every direction line says what happens today instead. Next, Later and Horizon say how much of a line already stands, not when it lands.
Live today
- A guarantee, held outside the code, with the plan that proves it approved by a person
- Execution of the running software in a real browser, with evidence
- A refusal to charge when no check could prove the claim, on every path that starts a run
- Human review, findings, and a repair package written for a coding agent
- Verified / Failed / Blocked decisions, with history preserved
- Deployed web applications and HTTP APIs
- API, an installable CLI, webhooks, GitHub, Vercel, and Slack
Direction
- The command line installs with npm installNextToday it installs from a script served as plain text, on macOS, Linux and Windows. The package is prepared and is not published, so npm install does not reach it.
- A plan is rehearsed before a person is asked to approve itNextToday a plan goes from prepared to approved with nothing having tried to run it in between. The rehearsal that refuses to mint a plan which cannot pass is an operator script, outside the product.
- Every run asserts a value no earlier run could have left behindNextToday a plan can assert a value an earlier run wrote, so software that has stopped saving can still come back Verified. Clearing that state is a script somebody runs.
- An outcome sentence is required when a system is connectedNextToday a contract that never named an outcome has no claim to gate, so its launches are recorded as ungated rather than counted as having passed.
- The repair reaches your coding agent on its ownLaterToday a failure writes a repair package onto the issue: what should have happened, what happened instead, and the evidence. Vraelis does not send it anywhere. You copy it.
- A repair is a durable record of its ownLaterToday the repair table exists and nothing writes to it, so the surfaces that read it are switched off. The repair package itself is real and lives on the issue and on the run report.
- A new deployment is noticed, and rechecked without being askedLaterToday Vraelis reads the deployment you point it at when a run is launched. Nothing watches for the next one, and every recheck is started by a person.
- One page per guarantee, showing every failure, repair and recheck in orderLaterToday each run records the guarantee and the exact approved meaning it was proved against. No surface puts that history in a line yet.
- Live agent activity read as it happensHorizonToday a check begins at the point work is claimed complete. Plans, code changes and tool calls are not ingested while an agent is working.
- Surfaces beyond a browser, and beside the agentHorizonToday the boundary is what a real browser and an HTTP client can observe from outside. Mobile, desktop and native applications are not covered.
- Reliability memory, and autonomy earned from a recordHorizonNot built. How much an agent may be trusted to do alone should be a conclusion drawn from what it has actually got right, rather than a setting somebody chooses.
How we build
The commitments the product is held to.
We ship what is real.
Live capabilities and directions are labeled separately, on the site and in the product. We would rather show an honest gap than imply a finished one.
The judge is independent of the builder.
Nothing an agent produces is trusted because the agent says so. Completion is a decision made on evidence by something other than the author.
History is preserved.
Failures and repairs are kept, not overwritten. The record is the point, because trust compounds from what a system has survived.
Autonomy should be earned.
How much an agent may do alone should be a conclusion drawn from responsibilities it has actually met, not a setting somebody chooses, and independent oversight should follow the work onto whatever it runs on. Neither is built: nothing in the product measures that record today, and the reach today is a real browser and an HTTP client.
Contact
Talk to the team.
Questions about the product, security, or working together are read by the people building Vraelis.
Support: [email protected]. Enterprise and invoicing: [email protected]. Privacy and data rights: [email protected]. What each is for →
Give agents more responsibility without giving up control.
Independent oversight, from the moment work is assigned to the moment it can be trusted. That is the whole mission.