Only the AI your software needs, inside the phone.

Frontier models know poetry, chess and a thousand things your company will never use. We train a small open model on only what your software needs, and run it offline on your users' own phones and laptops. Private, offline, with no cloud inference fee.

Try the interactive demo → Bring your software

Qwen3 0.6B · 6-bit · llama.cpp · measured on a 4 GB Galaxy A05s in airplane mode

Scroll to see how
The problem

Your users want AI. Your data can't go to the cloud.

The data leaves.

Patient files, bank records and contracts go to an AI company's servers, its logs and its country.

Every question costs you.

The more your users rely on the AI, the bigger the bill. Growth becomes a cost problem.

No network, no AI.

In a clinic basement, a branch office or a village, the cloud is simply gone.

How it works

We compile your software's intelligence into a small model.

Not a general chatbot squeezed down. A model trained for your software's actions and your users' words, sized for their device.

01

Learn your software

We map the actions your product can take, and the data behind them.

Action map
records.findvisits.summariseclaim.prepareticket.route+ more
02

Build a practice copy

A sandbox of your software with fake data, so the model can practise every action safely.

Sandbox
Real actions, fake dataisolated
03

Write the exam first

Real questions from real users, kept apart and never trained on, so the score is honest.

Benchmark
Held-out test setfrozen
04

Teach a small model

A big model teaches a small one your software, step by step, with every example checked.

Student model
Size
05

Guard it with code

Every number is checked against your data. Every change waits for a person to approve it.

Guards
Numbers checkedevery reply
Changesneed approval
06

Shrink it, test it on real devices

Packed to fit the phone, then tested on the real low-end phones and PCs your users own, against strict speed and memory gates.

Device report
pass
Model size MB
Under the hood

Simple outside. Serious engineering inside.

Two parts. A build pipeline that runs once, on our servers. A small runtime that runs on the device, for every question, with no network.

Your software
  • Its actions records.find bill.create
  • Its data, and how it is shaped
  • Questions your users really ask
Build pipeline our servers, once
  1. Map the actions
  2. Practice copy with fake data
  3. Freeze an exam, never trained on
  4. A big model writes checked examples
  5. Fine-tune a open model
  6. Pack it to 6 bits
  7. Pass speed and memory gates on real phones
On the device offline, every question
  1. Question, typed or spoken
  2. The model picks an action
  3. Your software runs it on local data
  4. Code checks every number
  5. Answer, or an Approve card
Airplane mode
Qwen3 Base model

A small open model (Apache-2.0). No frontier API, ever.

6-bitPrecision

Q6_K weights. The whole model is MB.

llama.cppRuntime

4 CPU cores on a . No GPU, no NPU.

MBMemory

The model in memory, on a phone with 4 GB in total.

tok/sReading

How fast it reads the question and your data.

tok/sWriting

How fast it writes the answer. About 11 in a long chat.

sFirst launch

Loads the model once. Then to s per answer.

Exam questions

Real questions from shops, frozen and never trained on.

Measured in Google's Firebase Test Lab on a real Galaxy A05s (Android 15), in airplane mode. The exam is scored on a server.

Engineering beyond the model

Our own runtime work, measured on the same phone.

s → sWake-up when the app is opened again. We save the model's warmed state on the phone, so it is 23x faster with identical answers.
reading speedOur own CPU kernel patch for older Arm chips, the kind inside cheap phones. Test build.
Every number checkedThe model picks the action; code computes bills, tax and stock from your data. A wrong number can't reach the user.
Proof

Already running inside a 4 GB phone.

Our first build is for Nesayo, an AI assistant for Indian pharmacies. We rebuilt its cloud assistant to run inside the shop's own low-end phone, with no cloud model at all.

Case studyNesayo

An AI assistant for Indian pharmacies: stock, bills and dues, by text and voice, in Hindi, Hinglish and English.

See Nesayo live →
Today: live product

Answers come from a cloud model.

Offline edition: our model inside the phone

Same assistant, airplane mode, on a 4 GB phone. Tested on real phones in a device lab. Shop pilot next.
MB

Model download. The whole AI.

tok/s

Writing speed on the phone's CPU.

s

To answer a lookup question, in airplane mode.

Accuracy on real questions: our model vs its 8B teacher.

MBof memory for the model, on a phone that also runs everything else.

checks, 0 wrongBill, tax and stock maths in the offline app, checked against an independent calculator.

features of the live cloud product working offline today.

Interactive demo

Ask it something. Nothing leaves the phone.

Pick a kind of software, then a question. Watch each step the model takes inside the phone, in airplane mode.

Nesayo (pharmacy): recorded phone results, replayed. Others: illustrations.

Open the full demo →

Who it's for

Software whose data should never leave the device.

Pharmacies (Nesayo) are our first build, measured on real phones. The others are the workflows we are building toward.

Use case

Health records

Patient summaries and follow-ups for doctors and health workers. Records stay on the device.

Try it →
Use case

Banking and lending

Loan files and collections for field agents, without sending customer data out.

Try it →
Use case

Legal and contracts

Clause checks and summaries on the lawyer's own laptop. Privileged files never leave it.

Try it →
Use case

Field inspections

Reports and checklists by voice, in a plant or a basement with no signal.

Try it →
First build · Nesayo

Pharmacies

Nesayo's assistant: stock, bills and dues by voice in Hinglish, on the shop's own 4 GB phone.

Try it →
Yours

Your software

Tell us what your users do and what data can't leave. We'll show you what fits on their devices.

Talk to us →
Security by design

The safest place for the data is where it already is.

With a cloud AI you protect the data on the way out, on their servers and in their logs. With Neykosa it never goes out.

Stays on the device

Questions, records and answers are processed on the phone or laptop that holds them.

  • No cloud model at run time
  • Works in airplane mode
  • Nothing for an AI company to log or train on
Checked by code

The model proposes. Code and people decide.

  • Every number checked against your data
  • Every change waits for approval
  • Unsure? It asks instead of guessing
Fixed and testable

A model that doesn't change under you, tested before every release.

  • Frozen test set, never trained on
  • Speed and memory gates on real devices
  • You decide when to update
What we believe

Small on purpose. Private by default.

Small

The smallest model that does the job well, on hardware people already own.

  • parameters, MB
  • Runs on a 4 GB phone's CPU
  • No frontier model behind it
Private

The data stays where it was made. The person using it stays in charge.

  • Nothing sent to an AI company
  • Every change waits for a person
  • Works with the network off
Made for its people

Built from the questions real users ask, in the words they use.

  • Hindi, Hinglish and English
  • Voice at a noisy counter
  • Tested on the phones they actually buy
Public tools and results

What we share with everyone.

Public

Low-end device benchmark

Speed of small models on cheap CPUs, run in the open on every change.

View on GitHub →
Coming next

How we test on real phones

Our speed, memory and no-crash gates for low-end Android, written up so anyone can reuse them.

Coming next

Open evaluation kit

Tools to build an honest held-out exam for any software, before training a model on it.

Side by side

A frontier cloud model vs Neykosa.

Frontier cloud modelNeykosa, inside the device
What it knows
Everything, and you pay for all of it
Only your software's tasks
Where the data goes
To an AI company's servers
Nowhere. It stays on the device
Who can see it
The vendor, its logs, its staff
Only people with access to the device
Where the AI runs
Rented GPU servers
The phone or laptop's own CPU
Internet needed
Yes, for every question
No. Works in airplane mode
Inference fee
Per question, grows with users
None per question

Big general jobs, like reading long scanned documents, can stay in your own cloud. Everyday questions don't need it.

Where this goes

Every app gets its own small AI. On every device.

Billions of phones and laptops already have the hardware. What's missing is a model made for each product, tested on the devices its users own. We're building the factory that makes them.

Building now

Android phones, first build tested on real devices

  • A tested model for one product on 4 GB phones
  • Text and voice, in Hindi, Hinglish and English
  • Code checks and approvals around every answer
  • Shop pilot next
Next

The compiler, as a product

  • Bring your software's actions, get a tested model back
  • Health, lending, legal and field-work pilots
  • iPhones, laptops and PCs from the same build
  • Phone AI chips (NPUs) where they exist, CPU everywhere else
Research

Small models that do more

  • Reading forms and bills on the phone with a small vision model
  • One small base with a tiny add-on per app, shared in memory
  • Improving from a user's corrections, without the data leaving
Why nowSmall open models became good enough in the last year. Cheap phones now ship with 4 GB or more. Privacy laws like India's DPDP Act push data to stay where it is.
Questions

Good to know.

Does anything leave the device?

Not for the AI. The model, the question and the answer stay on the phone or laptop, and it works in airplane mode. If your software already syncs its own data, that stays your choice and works as before.

Which devices does it run on?

Today: 64-bit Android phones with 4 GB of memory, like the Galaxy A05s, and Windows PCs. No GPU needed. We test on the exact devices your users have before we promise a number.

What exactly runs on the phone?

An open 0.6B model (Qwen3 family), fine-tuned for one product and packed to 489 MB, running with llama.cpp on the phone's CPU. Larger models only help write training examples before release.

Do we have to give you our customers' data?

No. We can build from your software's actions and synthetic data. If you share real examples, they stay private and are only used to train and test your model.

Is a small model good enough?

For one product, yes. It doesn't need to know everything, only your software. On real test questions our 0.6B model beat the 8B model that taught it.

What if the model gets something wrong?

Code checks every number against your data before it is shown. Anything that changes data waits for a person to approve it.

What do we get?

A model built and tested for your software, the on-device runtime, the code checks around it, and a test report from your users' real devices. We help you put it into your software.

How do we start?

Tell us what your software does, what data can't leave, and what devices your users have. We'll come back with what fits and how we'd prove it.

Bring your software

Keep the AI where the data is.

Tell us about your software. We'll tell you what can run inside your users' devices, and how we'd prove it.

  • A reply within two working days
  • Tested on your users' real devices
  • Your data stays yours

Prefer email?

Your users' devices

It comes straight to our inbox. We use it only to reply to you.