Your apps learn the part. Then they play it.
An understudy sits beside a method your Maestra app is already built from. It watches how your team handles that one task, learns it, and only steps on stage once it has earned the role, with a number to prove it.
Rehearsed by your team. Performed by your software.
Why this is even possible
Every Maestra app is born automatable.
Most business software was built for hands. The only way to make it do anything is a person clicking through screens, so the only way to automate it is a bot pretending to click. It is brittle, and it can only reach what is on screen.
A Maestra app is built differently. It is a list of typed actions, its methods, and every screen, API, and agent is just a window onto that list. So a person clicking Escalate and a model calling escalateTicket are the same event: same action, same rules, same line in the log.
Think of a stage production. The understudy doesn’t get a different script, a different set, or a different exit. They learn the same blocking as the lead and walk through the same doors. That is the difference between hiring a stand-in who improvises and one who knows the show.
This is why you can’t bolt it onto leased software. It isn’t a feature you add. It is how the app is built.
no interface — direct call
The shape in code
An understudy is a small file that sits next to a method.
The method stays exactly as it is: it validates, checks permissions, and applies the change. The understudy’s only job is to propose what the method should do. The method still decides. The agent walks through the same door as every person, and it can do nothing the app didn’t already allow.
1defineUnderstudy(sendReply, { 2 // The ticket the person saw, never their decision. 3 subject: (ticket) => ({ ticketId: ticket.id }), 4 5 // Propose the reply a careful teammate would send, or step back. 6 propose: async (ticket) => { 7 if (mentionsLegal(ticket)) return abstain(); // a person handles this 8 const body = await draftReply(ticket); 9 return { input: { ticketId: ticket.id, body } }; 10 }, 11 12 // Graded against the reply the person actually sent. 13 grade: matchesTheTeam, 14});
Shadow ledger · sendReply · last 30 days
would have agreed with your team
Put an action in shadow and nothing changes for your team. Every time someone does the task, the understudy quietly does it too, filing what it would have done next to what actually happened. Nobody relies on its decisions. You are just building the record that tells you when it’s ready.
The 13 percent where the understudy and your team part ways isn’t failure. It is the most valuable thing here: the exact cases where your team’s judgment and the model’s diverge, captured as they happen. That is the training set, writing itself.
It records app actions only, never keystrokes or screens, and it belongs to your organization. Nobody is being watched. The repetitive parts of the job are earning their own automation.
The loop
The role is earned one task at a time.
No leaps of faith. An action moves up only when the numbers clear the bar, and every promotion is a reviewed change you can undo.
Your team works the way it always has. Every action becomes a clean demonstration. There is nothing to opt into.
The understudy runs silently beside your team. You watch the agreement number climb before anything is handed over.
A person approves, edits, or rejects what the understudy drafts. The team moves faster, and every correction becomes training data.
Once the numbers hold, the action runs on its own. Exceptions still go to a person, and shadow keeps running to catch drift.
Not every action climbs all four rungs. A reversible one can go straight from shadow to performing on a slice of its traffic first. Approve is the permanent home for actions you never fully hand over, like anything that sends, publishes, or charges.
What you end up owning
Your team’s judgment becomes a model you own.
Here the stage metaphor breaks, on purpose. Leased software has spent a decade collecting how you work and selling it back as AI features. This turns that around.
Training here means one specific, well-documented recipe: supervised fine-tuning, then preference tuning. Take an action’s graded pairs, the context in and the decision out, and teach a small model to make that one call at a fraction of the cost. It drops into the understudy’s model slot like any other option, private to your organization.
Every run trains several candidates. Only the one that agrees most with your team ships, scored on held-out decisions against your own rubric. An update that would lose ground you had already won doesn’t ship.
Facts stay in retrieval, where they belong. Habits move into the weights.
A copilot sits next to a tool it can’t operate. An understudy walks through the tool’s own door.
A portfolio of small models, one per task, each with a record of exactly what it learned from.
It stays in shadow, proposing beside your team. The 87% you already trust becomes the before-and-after, at no risk.
A separate decision, later, argued from that model’s own live numbers. Demotion is undo.
Drafts customer replies. One task, trained on your team’s decisions.
with your team · rev 4
was 80% at rev 1
- Source app
- Front Desk
- Method
- sendReply
- Trained on
- 642 graded pairs
- Demonstrated by
- your team · 9 people
- Base model
- open weights · 9B
- Recipe
- SFT → preference
- Artifact
- adapter · ~180 MB ↓
- Owner
- your org · private
slot sendReply.understudy.ts
The economics
Small models, real numbers.
Every component is standard, proven, and open: the same stack any serious ML lab runs. What nobody else ships is the arrangement: it runs itself, per customer and per task, trained on your team’s graded decisions and scored against your own definition of correct.
Open weights, kept private to your organization. Small and mid-size classes by default, larger on request.
4–20B paramsA busy queue produces enough in about a week. Scale further later if you like.
hundreds → millionsDuration scales with the set. Reproducible: pinned dependencies, fixed seed, dataset fingerprint in the report.
minutes to hoursPriced per token of training data, so a typical action costs dollars, not a subscription.
priced per M tokensAn adapter: megabytes, not gigabytes. Small enough to hand you as an export.
a few hundred MBResident on the GPU around the clock, so there are no cold starts.
~50 ms to first tokenThe anatomy of a Maestra app
Every Maestra app is already shaped to hold understudies.
A learning agent needs six things. A Maestra app already has all six, built in for reasons that predate understudies entirely.
what the app should do, in writing
→ grading rulesthe typed list of every action
→ a fixed action setrepeatable test worlds in every app
→ factual gradingthe grading checklist, from the score
→ yes/no scoringevery interface calls the same methods
→ demonstrations, day onecatalog, metering, audit, roles, SSO
→ a runtime already runningThat is why the loop is hard to find anywhere else. Asking a vendor for a model trained on your own operations usually gets you a consulting engagement, not a product. Here an organization learns from its own work, on infrastructure it already runs.
Two pieces that compound
You start earning before you start training.
An understudy gets to work the day you switch it on: routing, drafting, escalating, deciding when to hand a case to a person. None of that needs machine learning. It is ordinary logic and model calls, with the ladder and the paired ledger already doing their jobs.
Fine-tuning takes that same work and turns it into a small model you own. It clicks into the understudy already running: same file, same grading, nothing new to learn. You aren’t adding a system. You are swapping in a better model.
The part that’s easy to miss: an understudy starts banking its record the day it goes live, long before training crosses anyone’s mind. By the time you want the model, the data already exists.
Keep your judgment in the building.
Move your operations out of leased software and into methods you own. Your team’s ordinary work becomes demonstrations. Understudies shadow until they’ve earned each part, and you decide when the curtain goes up.