Before there were certifications and onboarding decks, there were apprentices. You took someone on, showed them the work, and let them watch. Then they tried it, and you checked what they did. They got it wrong, you corrected them, and they tried again. Over months, they earned something specific — your trust, and the right to do the work without you standing over them. You were still the master. They were just no longer a beginner.
That's a good model for the boring, repeating parts of a job. It's almost exactly the wrong model for how we've tried to automate them.
Automation has offered two options, and both ask you to give something up. The first is the macro — record the clicks, play them back. A macro is brittle. Change one screen and it breaks, silently, and you find out when the work comes back wrong. The second is the unsupervised bot — hand it the keys and hope. The bot acts on its own, and the first time it does something you didn't expect, on live systems, you learn the cost of "hope." One option is too dumb to trust. The other is too autonomous to trust.
| The Macro | The Unsupervised Bot | XSI Apprentice |
|---|---|---|
| Breaks silently when a screen changes | Acts on its own, on live systems | Learns from a real demonstration |
| No judgment — replays clicks blind | Trust on faith, not evidence | Two human gates, every time |
| You find out when the work is wrong | The first surprise is the expensive one | Tracks the hours it gives back |
XSI Apprentice™ is the third option, and it works the way the old one did. You demonstrate a repetitive task once. Apprentice watches, and it turns what it saw into a workflow — a real, inspectable workflow on the Microsoft Agent Framework, not a recording of your mouse. From then on, the workflow never runs on its own. Two gates stand in the way: you approve the workflow before it goes live, and you review the work product on every run. Apprentice does the repetition. You keep the judgment. And it tells you, plainly, how many hours it gave you back.
Why "Apprentice," Not "Bot"
The word is the whole design. An apprentice doesn't ask for blind trust — an apprentice earns trust by doing the work in front of you, under your sign-off, until you're ready to give it more rope. That isn't a softer kind of automation. It's the kind a regulated team can actually adopt, because nothing the apprentice does is unwitnessed, and nothing ships without a human saying yes.
The Flagship Agentic Application
Apprentice is the first of our agentic applications for XSI-AIMS — tools built for the virtual worker and governed by the standard. Because Apprentice runs through XSI-AIMS, every step it takes is witnessed and accountable, and you watch and steer all of it through one pane of glass, XSI Helm. The apprenticeship isn't a metaphor we bolted on for the brochure. It is the governance model: train, gate, review, trust — in that order.
What I won't oversell: the governance came first, and it's built. The part that watches a demonstration and turns it into a workflow is still maturing, and I'd rather say that plainly than dress it up. Apprentice removes the repetition, not the judgment — it isn't here to replace the worker, it's here to give the worker their afternoons back. And it's for the work you can show it. New problems still go to a person, which is exactly where they belong.
So — do you have an apprentice? Not a macro that breaks when the screen moves. Not a bot you have to hope about. An apprentice you train, sign off on, and come to trust — doing the repetitive work you've done a thousand times, and handing you back the hours. You're still the master. It's just no longer a beginner.
It's in preview. If your team does the same task over and over, and you've wanted a better third option — come train one with us.
Q&A with Rhyan
Extended questions from discussions — answered in full.
A governed programming-by-demonstration agent tool. A worker demonstrates a repetitive task once, and Apprentice synthesizes it into a workflow graph on the Microsoft Agent Framework. It never runs on its own.
A macro is brittle and breaks silently when a screen changes. An unsupervised bot acts on its own and asks you to trust it on faith. Apprentice learns from a real demonstration, then runs only under two human gates — approval before it goes live, and review of every run's work product.
Gate 1 is ingress approval — a worker (not the one who demonstrated the task) approves the synthesized workflow before it goes live. Gate 2 is per-run review — the work product from every run is checked before it counts as done.
No. Apprentice removes the repetition, not the judgment. It handles the demonstrable, repetitive parts of a job; novel work still goes to a person. Built-in accounting tracks the hours it gives back.
Common Questions
Search-ready answers to the questions we hear most often.
XSI Apprentice is a governed record-and-replay / programming-by-demonstration agent tool. A worker demonstrates a repetitive task once; Apprentice synthesizes it into a workflow graph on the Microsoft Agent Framework, which then runs only under two-gate human approval.
A worker performs the task once while Apprentice observes. Apprentice turns that single demonstration into an inspectable workflow graph — not a brittle recording of clicks — that a human must approve before it ever runs unattended.
Gate 1 is ingress: a worker other than the one who demonstrated the task approves the synthesized workflow before it goes live (a Four-Eyes check). Gate 2 is per-run review: every run's work product is reviewed before it is accepted.
XSI Apprentice is in preview. Scope and availability are subject to change during preview.
XSI Apprentice synthesizes workflows on the Microsoft Agent Framework and registers through XSI-AIMS, an open governance standard, so every step it takes is witnessed and steerable through XSI Helm.