A new Remy primitive
Your software learnsto run itself.
Jewels are agent companions to the methods your Remy apps are already built from. They watch how your team works, learn one task at a time, and only step in once they've earned it, with a number to prove it.
Self-driving, for your business.
Why this is even possible
Every Remy app is born automatable.
Your current software was built for hands. The only way to make it do anything is a person clicking through the screens, so the only way to automate it is a bot faking those clicks. It is brittle, and it can only touch what is on screen.
A Remy app is built differently. It is a list of typed actions, its methods. Every screen, API, and agent is just a window onto that same list. So a person clicking Escalate and a model calling the escalate method are the same event: same action, same rules, same line in the log.
In a modern car, the pedal does not pull a cable. It sends a signal, and the computer can send that same signal. That is the difference between bolting a robot into the driver's seat and building a car that can drive itself. Remy apps are built with the controls exposed from day one.
This is why you cannot get here from Salesforce. It is not a feature you add. It is how the app is built.
Two origins
The same door
One log
the only field that differs ↑
The shape in code
A jewel is a small file that sits next to a method.
The method stays exactly as it is: it validates, it checks permissions, it applies the change. The jewel's only job is to propose what the method should do; the method still decides. The agent walks through the same door as every human, and it can do nothing the app did not already allow.
defineJewel(sendReply, { // The ticket the human saw, never their decision. subject: (ticket) => ({ ticketId: ticket.id }), // Propose the reply a careful teammate would send, or abstain. propose: async (ticket) => { if (mentionsLegal(ticket)) return abstain(); // a human handles this const body = await draftReply(ticket); return { input: { ticketId: ticket.id, body } }; }, // Scored against the reply the human actually sent. grade: matchesTheHuman,});The jewel's output is exactly the method's input. Nothing to keep in sync, nothing that can drift. It can also abstain, and an honest "a human handles this" is a first-class answer.
SHADOW LEDGER · sendReply · LAST 30 DAYS
0%
would have agreed with your team
Turn an action to shadow and nothing changes for your team. Every time someone does the task, the jewel quietly does it too, filing what it would have done next to what actually happened. Nobody is driving on its decisions. You are just building the record that tells you when it's ready.
The 16 percent where the jewel and your team diverge is not failure: it is the most valuable thing here, the exact cases where your team's judgment and the model's part ways, captured the moment they happen. That is the training set, writing itself.
It logs app actions only, never keystrokes or screens, and it belongs to your org. Nobody is being watched. The boring parts of the job are earning their own automation.
The loop
Autonomy is earned one task at a time.
No leaps of faith. An action climbs the ladder 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’s nothing to opt into.
The jewel runs silently alongside your team. You watch the agreement number climb before anything is handed over.
A human approves, edits, or rejects what the jewel drafts. Your team moves faster, and every correction becomes training data.
Once the numbers hold, the action runs on its own. Exceptions still go to a human, and shadow keeps running to catch drift.
Not every action climbs all four rungs. A reversible one can go straight from shadow to acting, easing in on a slice of its traffic first. Approve is the permanent home for the actions you never fully hand off, like anything that sends, publishes, or charges.
What you end up owning
Your team's work becomes a model you own.
Here is where the car metaphor breaks, on purpose. A carmaker keeps the model its whole fleet trains and rents the smarts back to you. Your SaaS vendors have done the same for a decade: collect how you work, sell it back as AI features. This flips it.
Training here means one specific thing, the same recipe every open-model lab publishes: supervised fine-tuning, then DPO. Take an action's graded pairs, the context in, the decision out, and teach a small model to make that one call at a fraction of the cost. It drops into the jewel's model slot like any other option, private to your org.
Every run trains several candidate models. Only the one that agrees most with your team ships, scored on held-out decisions against your own criteria. The winner answers to your truth, not a public benchmark. Where you and the model still part ways becomes the next lesson: a preference-tuning stage (DPO) that ships only if it beats the plain fine-tune on that same grader, so an update can't quietly lose ground you'd already won.
- Not RAG.Facts stay in retrieval, where they belong. Habits move into the weights. Behavior, not knowledge.
- Not a copilot.A copilot sits next to a tool it cannot operate. A jewel walks through the tool's own door.
- Not one big "company AI."A portfolio of small models, one per task, each with a birth certificate. One big model can never tell you what it was trained on. A portfolio answers, line by line.
The safe swap
Once it's trained, putting your model to work is one line on the jewel. Its autonomy doesn't move.
Demotion is undo.
MODEL CARD
support / sendReply · v4
A model that drafts customer replies. One task, trained on your team's decisions.
84%
held-out agreement · the run's best candidate, your rubric
- Source app
- Support Desk
- Method
- sendReply
- Trained on
- 728 graded pairs
- Demonstrated by
- your team · 9 people
- Base model
- 9B · Apache-2.0
- Recipe
- SFT → DPO
- Artifact
- LoRA adapter · ~180 MB
- Owner
- your org · private
Trained on your work, and only your work. Never pooled, never another org’s data.
SERIAL 3F·A8·4C·91
slot sendReply.jewel.ts
The economics
Small models, real numbers.
Every component here is standard, proven, open. It’s the same stack any serious ML lab runs. No one else ships the arrangement: it runs itself, per customer and per task, trained on your team’s own graded decisions, scored against your own definition of correct.
The pipeline runs on Remy’s own infrastructure.
The anatomy of a Remy app
Every Remy app is already shaped to hold jewels.
A learning agent needs six things. A Remy app already has all six, built in for reasons that predate jewels entirely. Here is what each part is, and what it hands every jewel for free.
This is also why the loop is hard to get anywhere else. No frontier vendor trains a model on your operational data, self-serve fine-tuning is being phased out, and asking for a custom model gets you a consulting engagement, not a product. Here, an org learns from its own work, on infrastructure it already runs. The difference is not a better model. It is a model trained on your work, on the pieces above, that you own.
Two pieces that compound
You start earning before you start training.
Jewels
A jewel gets to work the day you turn it on: routing, drafting, escalating, deciding when to hand a case to a person. None of that takes any machine learning. It's ordinary logic and model calls, with the autonomy ladder and the pair ledger already doing their job.
Fine-tuning
Fine-tuning takes that same work and turns it into a small model you own. It clicks into the jewel already running: same manifest, same evals, nothing new to learn. You're not adding a system. You're swapping in a better model.
Here's the part that's easy to miss: a jewel starts banking that record the day it goes live, long before training is on anyone's mind. By the time you want the model, the data already exists. You've been building equity in the system since day one, for free.