syin automates work inside software that has no API. A frontier model shows it a task once; after that a small model on your own machine repeats it — and nothing counts as done until syin can prove it on screen.
The software that runs healthcare, insurance and finance publishes nothing.
The work that matters most in regulated industries happens inside screens with no API. Automating it has meant brittle scripts, or paying a model to look again at every single step.
No API to call
Portals, ledgers and records systems expose a screen to people and nothing to software.
Legacy desktop and ERP
The systems of record rarely offer what automation needs, on the tiers people actually use.
Automation that guesses
Today's tools break when an interface changes, or report a task as finished without checking that it was.
One program that perceives, then operates.
Ten stages in a closed loop. The first six work out what is on the screen; the last four do the work and prove it happened.
Teach once. Repeat locally.
A frontier model of your choice does the task live, once, on the real screen. syin turns that run into a lesson — kept only after an independent check that the work really happened. From then on a small model on your own machine repeats it with new details each time, and the frontier model isn't needed.
- Anthropic
- OpenAI
- Amazon Bedrock
- OpenRouter
- Any compatible endpoint
- Local models
Teaching: average of 8 teaching runs. Repeats: 27 local runs. Both measured 7 October 2026.
Watch the whole pipeline work.
Five short films: seeing a screen, teaching a task, repeating it with proof, handling pop-ups and private details, and the record of every step. Tap any film to watch it full screen.
One repeat, end to end.
A transfer the teacher showed syin once, repeated with a new amount by a small model on the machine. Every step is checked on the screen, and "done" needs proof.
Follow what was taught
The kept lesson brings its steps and what each one should change.
Choose the accounts
Each choice must show in its field before the next step.
Type the details
Typed key by key, then read back from the field it went into.
Transfer, then prove it
The amount must appear on its own line, under Debit, moving the right way.
Done means proven.
Typed values are read back
Every value is checked in the very field it was typed into.
Amounts land where they belong
On their record's own line, under the right column — not just somewhere on the page.
Choices stick after saving
Options picked from a list must still show once the record is saved, and transfers must move the right way.
Nothing quietly undone
If a page clears a field before saving, syin notices and puts it back first.
Every step on the record.
Watch any run step by step: what each step did, the screen before and after it, and who made each decision — the lesson, a local model, or the teacher — with the time and tokens it took.
- Decisionwho chose this step, and why
- Actionthe click or the keys, exactly as made
- Evidencewhat changed on screen
- CostAI calls and tokens, per step and per task
Private details stay private. Risky buttons stay unpressed.
These behaviours are built into syin itself, not left to a prompt.
Private details masked
Emails and ID numbers are replaced with placeholders before any cloud model sees them, and typed back in on your machine.
Repeats run on your machine
Once a task is taught, a small local model repeats it. Sending screenshots to a cloud model is off until you turn it on.
Pop-ups handled the safe way
Cookie banners are refused, upsells dismissed, sessions kept. Across 234 injected pop-ups, no accepting button was pressed.
Risky buttons need your words
Accept all, Subscribe, Upgrade and Log out are never pressed unless your request asks for them. System permission prompts are left for a person.
Your keys, your account
Connect your own AI account in one step. Keys stay in your system's secure store and are always shown masked.
Calls logged without content
Every model call is logged — which model, when, how many tokens — without what was sent.
Everything in one pipeline.
Everything below is built and tested today.
| Capability | What it does for you |
|---|
Tested against real business software.
58 tasks across five kinds of application. Every result is checked independently, against the application's own data — not against syin's opinion of how it went.
ERP
Orders, customers and products.
Banking
Transfers, payments and account activity.
Healthcare
Patient records and appointments.
Accounting
Ledger entries and registers.
Spreadsheets
Data entry and formatted reports.
Built for work that happens on a screen and nowhere else.
syin works from what is on the screen, so it fits software that offers nothing else.
| # | Who it's for | The work |
|---|---|---|
| 1 | Healthcare administration | Records entry and payer portals with no API |
| 2 | Insurance | Carrier portals and agency software |
| 3 | Finance and accounting | Banking portals, ledgers and reconciliations |
| 4 | ERP operations | Orders, invoices and rekeying between systems |
Everyone else pays to think again, every time.
| Approach | How it works | What that costs you |
|---|---|---|
| Computer-vision RPA | Images sent to a server, per action | Latency on every step; screens leave the site |
| Scripted RPA | Hand-built selectors and recorded clicks | Breaks when the interface changes |
| Frontier computer-use models | Re-read the screen and decide at every step | Frontier prices on every run |
| syin | A frontier model teaches once; a local model repeats | No planner calls on repeats; done is proven on screen |
An advantage that compounds with every run.
The moat is what syin accumulates by running: proven lessons, and the evidence behind them.
Lessons accumulate
Every proven lesson is kept, versioned and reused — and carries over to new tasks of the same shape.
Proof is data
Every run that is proven on screen is a labelled example of real work done right.
Better models, better teachers
As frontier models improve, teaching improves. Repeats stay local and cost nothing in planner calls.
Private by design
Private details are masked before any cloud call, and the repeats run on your own hardware.
See any screen. Do the work. Prove it's done.
Design partners
Teams doing repetitive work in business software with no API to call.
Regulated operations
Healthcare, insurance and finance teams that need to see who did what.
Your own hardware
Repeats run on a small model on your machine, with private details masked.