SAGE sits in the lecture, watches the slides, reads the material, and answers when it counts — quizzes, tests and essays, written the way you write. It listens, it evaluates, it decides, then it evolves between classes from what it got right. Self-hosted, installable on a phone.
$ cp .env.example .env # your gateway key $ npm run dev # http://localhost:8787 — no dependencies
Four ways in, one persona out. Everything it perceives is folded into the same memory, so a slide and a sentence from ten minutes ago can answer the question being asked now.
Live lecture transcript through on-device speech recognition, chunked into notes that keep definitions, numbers and the words EXAM: — everything the instructor stressed.
Screen share, phone camera, or an uploaded screen recording. Frames are sampled and read as they change, so a whiteboard becomes notes while it is being written.
Slides, photographs, handouts and pasted chapters become study notes with the formulas exactly as given, likely exam questions, and the gaps the material leaves.
It commits to an answer with a confidence score and the reason it knows, rather than hedging. Ambiguity gets the most likely reading and one clause saying so.
Quizzes answered one decision at a time, and essays with a real argument — citing only the material you supplied, never inventing a reference.
After class it reviews its own notes and rewrites its behaviour: how this instructor grades, which answer shape earned marks, how you like to sound.
No hand-waving: a web page cannot read an iPhone screen or a cast stream. Here is exactly what works, checked against what the browser exposes.
| Source | Capturable | How |
|---|---|---|
| Android Chrome — whole phone screen | yes | Watch → pick the screen, including other apps |
| Desktop browser — tab, window or screen | yes | Watch → pick the surface |
| Mirrored iPhone (AirPlay to a Mac/PC) | yes | Watch the mirroring window |
| iPhone screen directly | no | iOS has no capture API — use Control Center recording, then Read the video |
| Camera — board, projector, TV | yes | Aim |
| TV cast stream (Chromecast / AirPlay) | no | The stream never reaches the page — aim the camera, or capture on the receiving computer |
| Worksheet, textbook page | yes | Photo → Answer or Read |
Mic and screen capture need a secure context: https:// or localhost. A bare LAN
address loads the interface but not the capture.
SAGE speaks plain OpenAI-compatible HTTP, so the gateway is a base URL and a key — nothing else. This build ships wired to Innotel OmniRoute.
https://gateway.innotel.us/v1agy/gemini-3-flash, text and vision in about a secondAI_BASE_URLopenrouter
connection that is excluded, so server transcription answers 403 — SAGE detects that once
and falls back to on-device speech recognition instead of retrying forever.
$ curl -s https://gateway.innotel.us/v1/chat/completions \
-H "authorization: Bearer $KEY" \
-H "content-type: application/json" \
-d '{"model":"agy/gemini-3-flash","messages":[{"role":"user","content":"OK"}]}'
Plain Node with no dependencies, or a Cloudflare Worker — the same src/app.mjs handler serves
both. The phone app is the same page, added to the home screen.
src/persona.mjs holds the identity rules and one contract per task: note, answer, quiz, essay, read, phrase, evolve.
The key lives in .env, gitignored and never served — the browser only ever talks to your own API.
A PWA with a manifest and offline shell. Add to Home Screen and it opens standalone, with its own icon.
The hard part is not answering a question — it is answering one while another app owns the screen. Study mode runs listening and watching together and answers unprompted; the relay covers devices that cannot capture themselves.
One toggle: microphone and screen together, notes accumulating, and an answer offered the moment a question lands — throttled to one every 45 seconds so it stays quiet.
A computer sharing a mirrored phone or a TV cast window publishes frames under a short code. Your phone joins the code and does the thinking, with the course app still in front.
Android Chrome can capture the whole device: start Watch, switch to the course app, and the frames keep arriving — screen and audio together.
Shipped is shipped; the rest is named honestly.
as of v6.0.1 — 24 shipped, 8 deferred, 10 planned
Listening, watching, reading, quiz and essay surfaces, self-evolution memory, gateway wiring, PWA install.
Study mode with automatic question detection, and the cross-device relay for mirrored phones, tablets and cast windows.
The best model the key can actually call is chosen for you — no model setting to get wrong — and a session bought at Magnate installs itself from its receipt.
Per-task routing: running notes go to the fastest model the key can call, answers and essays to the strongest — both picked automatically.
The session clock: the minutes left on a bought session are on screen, and capture stops by itself when the window closes.
Capture that survives playback: the microphone is reclaimed when a video interrupts it, a screen recording imports and reads in one tap, Settings closes with an ✕ and never opens itself, and a question's photo is cleared after the answer.
The operator panel: the access code, model routing and a seven-day usage tally behind Cerulean SSO — set from a phone, no restart.
Foundation documents: a course carries its own PDFs, Word files, screenshots and recordings, read once and then used to ground Answer, Quiz and Read.
Grounded essays: the documents reach Essay too, and a grounded reply names the files it leant on.
A question survives the network: if the server cannot be reached it is kept on the device and answered when the connection comes back, in the tab that asked.
Essay takes photographs: the prompt, a handout or a page of handwritten notes is attached instead of typed, read before a word is written, then cleared so the next essay never inherits it.
Capture that outlives the app: a ReplayKit broadcast extension keeps reading the screen with Sage in the background or the phone locked, Android keeps its foreground service, and the server joins the two.
A kept turn keeps its photos: a question photographed with no signal is stored with its images, replayed once with the picture attached, and the images are dropped when the answer lands.
A citation you can turn to: a reply names the page it used as [file p.N], and the page opens from the copy the course already holds — never an invented page.
Exam rehearsal: a timed paper set from the course, sat in the app with the clock running, and marked question by question — with no answer on the page before you submit.
Audio-only lectures: notes from a recording with no screen, each stamped with the moment it came from — and the recording kept on the device, so a note replays it at that offset.
One search across every course: a phrase finds the note, the answer and the page it was taught on — on the device, and each hit opens where it came from.
Spaced revision: what you got wrong comes back on 1/3/7/21-day intervals until it sticks, in a five-minute daily session.
Handoff between devices: a live session record follows you from the phone to the laptop, and only one device holds the microphone.
Documents that work offline: the handout is cached under a size budget, and a question asked with no connection is answered from the copy, page intact.
Accessible and multilingual: capture and replies are announced, the citation viewer keeps focus, and Arabic runs right to left with its punctuation intact.
Share a course: a read-only link carrying the notes and the documents, with the sharer's name on what they contributed, and no personal memory on it.
Measured grounding: a golden set per course, scored in CI and against the gateway, so a citation that points at a page the material does not have fails the release.
Next — the plan through v7.0, in the order it ships.
A share that stays honest: a shared page says which revision it is, and the owner publishes a new one without changing its address.
Group revision: a classmate's questions join your revision queue, merged by content and labelled with the course they came from.
The marking scheme, learned: a paper marked criterion by criterion against the scheme you supplied, with the material you missed named.
Answers that cite the recording: a claim points at the lecture moment, and the chip plays it from there.
A timetable that starts the lecture: capture begins with the class and ends with the window.
A budget you can see: per-course and per-day token caps, enforced on the server and stated in the app.
A workspace you can carry: one archive, restorable on another instance, with documents stored once by hash.
The shared page, for everyone: keyboard, screen reader, print and right-to-left all reach a share.
The lecture, as a document: captures become a course reader whose every claim opens the page or moment it came from.
Questions about the reader: a question maps to the section that answers it and cites the section as well as the page, and a question that spans two lectures says so and cites both.
A question bank with shape: items built from the reader, past papers and what was marked wrong, deduplicated, each carrying the topic it tests and a difficulty learned from how it was answered.
Uncertainty that means something: stated confidence is calibrated against the golden set, a claim below the calibrated threshold is labelled rather than hidden behind a bar, and the score is recorded per release.
Papers with the shape of the real one: a practice paper matches the sections, the marks and the choice of a supplied past paper, and the clock, the marking and the revision sheet follow that shape.
Feedback that teaches: each lost mark points at the criterion, the page and the shortest path to it, and the revision sheet is built from those pointers in the order to revisit them.
A plan for the weeks before: an exam date turns the revision queue into a plan that survives a missed day.
The reader, shared: a lecture reader shared read-only, with attribution and the revision it was cut from — never memory, answers or the plan.
The reader, offline: cached per course under a size budget with each cached section marked, and a question asked with no connection kept with its section and answered from the cache, page labels intact.
The reader in your language: the source text stays and an explanation in the course's chosen language sits beside it, direction per block, the citation preserved.
The course, understood: a coverage map, the evidence behind each gap, and a measured answer to what to do this week.
The native build exists and the purchase flow is wired, but it is not in the App Store yet — no listing, no download badge, nothing to install from a store link. When review is done this page will say so.
Open sage.innotel.tech in Safari and use Share → Add to Home Screen. It runs full screen with its own icon, and every surface except direct screen capture works exactly as it does on the desktop.
A ReplayKit broadcast extension that keeps reading the screen while the course app is in front, and StoreKit sessions bought inside the app instead of a card at checkout.
Built and tested; submission is the remaining step. If you want the build before it is public, ask for a TestFlight invite — that is the only honest way to get it early.
Bought as a timed session — no subscription and no auto-renewal. Five minutes for the trial, once per person; fifteen for the others. The model is included, on our gateway.
Five minutes of model access, offered once per person and once per connection: the whole flow, from listening to answers, before you spend more.
Fifteen minutes of model access with every surface: live lecture notes, screen reading, quiz, essay and memory.
Fifteen minutes with the strongest model the gateway serves on answers and essays, and the most messages per session.
Managed, or self-hosted. A hosted Sage runs this build for you, sold by the session. The source stays open — the same repo still runs on your own machine with your own key, from Get started.