How it works
Describe it. It proves it.
Then it does the work.
You describe the role in a sentence, it proves it can do the job, you set the rules, and it gets to work — earning more autonomy as it goes. No technical setup, nothing to wire together. Here’s the whole thing.
You describe the role
Write the job in plain English. Praxa compiles that sentence into a verification plan — its own definition of what doing this job well looks like — and builds the employee for it. Have someone who already does the job? It learns from their real work too.
For example — “Triage every new support ticket and draft a reply in our voice.” That’s enough to start.
It proves it can do the job
Before it touches anything, Praxa auto-builds a test from the role — including the cases where the right move is to refuse or escalate — and grades the employee against it. It has to clear your bar at the deploy gate before it goes live — and we keep making that gate stricter.
For example — It’s scored on real examples of the work, two-sided: rewarded for acting AND for holding back when it should.
You set the rules
Decide what it can do on its own, what it should run by you first, and what it must never touch. Add a spending limit. It can't step outside the lines you draw — that's enforced in code, not a promise the model could be talked out of.
For example — Let it draft replies on its own, but always check with you before it issues a refund.
It works — and earns autonomy
It starts the moment the work shows up and does the job: drafting, fixing, replying, filing. Risky steps pause and wait for your yes, then resume exactly where they left off. As it proves itself, you can let it do more of the small stuff on its own.
For example — A new lead comes in at 2am. By morning it’s qualified, the first reply is drafted, and the meeting invite is waiting for one click.
What everyone asks
"But is it actually any good?"
Fair question — and you don’t take our word for it. Before it starts, Praxa tests the employee against real examples of the job, two-sided: it has to get the work right and hold back when the right move is to refuse or escalate. It doesn’t go live until it clears the bar you set.
Once it’s working, its results are checked against the real world — never self-graded — and measured across repeated runs, so “it’s reliable” is a number you can see. If quality ever slips, it stops on its own and tells you.
You approve the big stuff
Anything that spends money or a customer sees waits for your yes. Everything else, it just handles.
Everything is on the record
For every action you can see what it did and why — and that record can’t be edited later.
You can stop it anytime
One click pauses everything. And it pauses itself if its quality ever slips.
For the technical folks
What’s actually happening under the hood.
Not a chat window with a system prompt. A governed, durable agent loop with a real proof engine wrapped around it.
Want the full trust model and our decision records? Read the trust model →
- A real multi-step loop, not one shot
- Each job runs as a governed, multi-turn loop on durable infrastructure. It reads, acts, observes the result, and decides the next step — recovering from errors and surviving restarts mid-task instead of giving you a single best guess.
- Durable approve-and-resume
- When it hits a step that needs your yes, the in-flight task pauses — not a re-run later, the actual suspended job. Approve, and it resumes exactly where it left off and executes the byte-exact action you approved. Nothing else can slip through on that approval.
- Honest outcome verification
- It never grades its own work. A separate pass re-reads the real world to confirm the action landed, and reliability is reported as pass^k — how often it works across repeated trials. A role that hasn’t cleared its eval suite is held back at the deploy gate.
- It can pick up new tools
- Beyond its built-in connectors, an employee can acquire vendor tool surfaces over MCP, and run code in a per-task sandbox isolated from every other tenant and run. The capability set grows without us hardcoding every integration.
- It gets better with every job
- Proven skills are captured and compound, so the next hire starts ahead, and semantic memory means it learns how your team works and gets faster over time. Autonomy is earned: prove a step is safe and you can let it stop asking.
- It cannot go rogue, even if tricked
- Tool allowlist and memory namespace are enforced in middleware, not by a prompt. Prompt-injection and taint defenses sit on untrusted inputs, effects are exactly-once, and every action lands in an append-only audit log — with approvals and governance decisions hash-chained, so a single altered entry is obvious.
See it for yourself
The fastest way to get it is to see it.
Poke around a live workspace — no signup, nothing to install.