Project Exo  /  Aska Digital  /  In active build

Every model,
fitted to you.

Exo is one system for working well with models. It keeps a signed record of your work, builds a model of you from it, remembers what matters, learns your taste and grows with you. Built to fit one person deeply. Built to work for anyone.

Wave 1
Core skeleton built
Wave 2
Re-home plugins: next
Horizon
Portable companion device

01 / The problem

Models get smarter every month. Working with them still feels like meeting a stranger every morning.

They forget

A new session starts from zero. Your context lives in one vendor's chat history, or nowhere at all.

They do not learn

You correct the same mistake again and again. The fix lives in one session and dies with it.

They eat your attention

Approve this, confirm that. People cannot watch quiet systems all day, so endless approval queues fail.

Everything is split

Agents, memory, sessions, dashboards and notes are separate tools. None of them shares what it knows.

What stops people from handing real work to models is missing context, not missing intelligence. Exo exists to close that gap.

02 / Vision

One system. Five jobs that are usually separate.

A tailor does not make you a suit from a size chart. They measure you, cut, fit, and adjust over the years as you change. Exo does the same for models. It measures you through your own record of work, fits every model to you, and keeps adjusting. Today that work is spread across five kinds of tool. Exo puts them in one system, so each part can use what the others know.

  1. 01

    A model of you

    A picture of how you think, decide and write, built from a signed record of your work and words. Every model you use reads it first. When it is unsure what you would want, it asks.

  2. 02

    Harness

    The code around a model that lets it act. Exo's harness runs agents (models that use tools to do work), an orchestrator that splits a job and hands out the parts, and routing that sends each part to a cloud or local model.

  3. 03

    Memory

    A continuing relationship across sessions, platforms and agents. Every belief Exo holds about you can answer the question: why do you believe this?

  4. 04

    Context and sessions

    Gives the model the right material for each step, and no more. Keeps long sessions sharp, lets you branch a session to try another path, and hands work cleanly to the next session.

  5. 05

    Command centre

    One view of every project, every running agent and task, and every decision waiting on you.

Goal one

Fit one person deeply

A system like this is only worth having if it really knows you. Exo learns your rulings, your voice, your taste and your limits, and keeps learning.

Goal two

Work for anyone

The core is generic. Everything about a person lives in their own store, built by an onboarding interview. A fresh install with an empty store runs end to end.

Every part of Exo splits the mechanism, which ships to everyone, from the person, which lives only in their own store. Nothing in the core may assume one user's accounts, machines or names.

03 / Horizon

Later, a companion you can carry.

In a few years, Exo should live in a small portable device, something like a mini robot or a charm you wear, that grows and evolves with its user. We design for that now: the personal store is one portable folder, the core stays lean on purpose, and there is a small, local model path from day one.

  • StoreOne folder. Moves to a new machine or a device.
  • CoreA cap on lines of code, checked by tests from wave 1.
  • ModelsSmall models on the device by default. Cloud when worth it.
  • ProtocolWorks over a slow link, a tiny screen, or voice only.

04 / How it works

A signed record at the bottom. Everything else is a view you can rebuild.

Read the stack from the bottom up. The ledger is a record of every event that can grow but never be edited. Your store holds what Exo has worked out about you from that record. The learning loop tests new lessons before they count.

The core does the work: it talks to models, runs tools and keeps sessions. At the top, every screen you use talks to the core in one shared format, called the protocol.

01

The signed ledger

If a system's memory of you is a file it keeps rewriting, you cannot tell what changed, who changed it, or rebuild it later.

Think of a bank statement. Your balance is worked out from a list of transactions that is never erased. A mistake is fixed with a new entry, not by rubbing out an old one.

Exo's ledger works the same way. Every event is added to the end: what you said, what you ruled, what agents did, and whether you accepted, edited or rejected it. Each entry carries a digital signature (Ed25519), a mark only its author's private key can make, so anyone can check who wrote it.

Each entry also holds a hash of the one before: a short fingerprint that changes completely if one character changes. Edit an old entry and every fingerprint after it stops matching.

Your profile, memory and skills are worked out from the ledger, like the balance. When a better model arrives, it reads the ledger from the start and catches up.

02

The personal store

What Exo knows about you should belong to you, move with you, and be quick to search.

So it lives in one folder you can copy: a one-page summary called the pack, an index called the router that says where each kind of knowledge lives, beliefs (claims about you, each with its evidence and how sure Exo is), imported items such as notes and bookmarks, and the ledger itself.

Search works two ways at once. Keyword search finds exact words. Embeddings find meaning: a small model turns each passage into a list of numbers, so passages about the same idea sit close together even when they share no words. "My flight home" finds a note about "the return trip".

Exo merges both results, follows links to related notes, and stops at a token budget. A token is a piece of a word, and the budget caps how much text the model is handed. The embedding model runs on your machine, so your text is never sent away to be searched.

03

Memory in tiers

A model can read only so much at once. This limit is its context window. Give it too little and it forgets you. Give it everything and it gets slow, costly and confused.

An office solves the same problem with a desk, a filing cabinet and an archive. What you use every minute sits on the desk. What you need now and then is in the cabinet. The full record is in the archive. Exo keeps four tiers, and each one is rebuilt from the one below it.

T0LedgerThe archive. Every event, signed. Never put in front of the model whole.
T1BeliefsThe cabinet. Facts, dates and people, with evidence, confidence and the dates they hold true. Fetched with sources when a question needs them.
T2PackThe desk. One page: who you are, your rulings, your voice, your approval rules. Read every turn, and kept ready so it is cheap to reload.
T3Working contextThe page in front of the model for this turn. Built fresh each time.

04

Fresh context every turn

Most chat tools send the whole conversation to the model every time you write. It grows until early details get lost, and old mistakes keep coming back.

Picture joining a long project. You do not reread every word of every meeting. You read the minutes, then listen closely to the last few minutes of talk.

Exo does that. Each turn, one message from you and one reply, is a new call to the model. Exo builds it from a summary tree: small groups of messages are summarised, then groups of summaries are summarised, like chapters under a table of contents.

The latest messages go in word for word. The turn waits until the summaries are up to date, so nothing falls into a gap. Summaries are written in parallel, with live chat ahead of imported history.

05

Gates by reversibility and exposure

Ask for approval on every step and people stop reading and approve everything. Ask for none and one bad step can cost a lot.

A family can let anyone move the furniture but need two signatures to sell the house. What matters is not the size of the step. It is whether it can be undone, and who else it reaches.

A gate is a check that runs before an action, and Exo's gates ask those two questions.

Private steps that can be undone run at once and are logged. Steps that cannot be undone, or that are public, involve money or reach other people, wait for your answer, with a link and a suggested reply. Every outside action is tied to a named person. Rules that protect other people sit outside the model of you, so learning your taste can never argue Exo out of them.

06

Decision models for small choices

Many choices in a session are small: which tool, which model, which label, whether to open a panel. Asking a large model each time is slow and costly, and it answers in prose that then has to be read.

A firm does not ask a senior partner which folder a letter goes in.

Exo sends these choices to a decision model: a small model that is given a fixed list of options and returns how likely each one is to be right, such as "tool A 0.82, tool B 0.11". The numbers show how sure it is, so Exo can act when it is confident and ask when it is not.

The default is Laya, which runs on your machine, free and private. Users can choose TypeSafe Jev, Perplexity's decider or OpenAI's Decisions API instead. A decision model may make a gate stricter, never looser. Every decision is logged so the learning loop can score it.

07

A standalone core with a protocol

Most assistants are tied to one app. Move to a phone or a new screen and you start again.

Email solved this long ago. One mail server holds your inbox, and any mail app shows the same inbox, because they all speak the same standard.

Exo's core, exod, is a small Python program that does the real work. It runs each turn, picks which model should answer (the model router), calls tools and keeps sessions.

The terminal, web, desktop, chat channels and a future device are clients: screens that talk to the core through one protocol. Everything that happens is sent as an event with a fixed shape and a number in sequence. A client that drops off asks for every event since the last number it saw, so nothing is lost. A cap on lines of code, checked by tests, keeps the core small enough to fit on a device.

08

Lifted with credit, improved on purpose

Writing everything from scratch wastes years. Forking a large project, which means copying it and changing the copy, brings all its weight and slowly drifts away from the original.

Exo is its own harness. It lifts a small set of proven modules from Hermes Agent (MIT licence) and writes the rest small. Every lifted file carries a header and a row in a provenance file, which records where it came from and the exact version.

Each week Exo compares those files with the original project and proposes fixes worth bringing over. Good changes still flow in, by choice rather than by dependency.

This page is the overview. The whitepaper covers each part in depth, with the reasoning and the trade-offs.

05 / The learning loop

It learns from you. Then it proves the lesson helps.

Many assistants that "learn" save notes and hope they help. But a lesson can make things worse. "Keep it short" may improve your emails and ruin your contracts. Exo treats each lesson the way a cook treats a change to a recipe: make it both ways, taste blind, and keep the new version only if it wins.

  1. 1

    Capture

    Corrections, edits, accepts, rejections, direct requests and outcomes are written to the ledger. A correction teaches the most, because it shows exactly where Exo was wrong.

  2. 2

    Review

    A reviewer works in the background, apart from your conversation, and turns those events into proposed lessons, each with its evidence and confidence. It only proposes. It never changes anything in silence.

  3. 3

    Climb

    This is hill climbing. Imagine finding the top of a hill in fog: take one step, check whether you went up, and keep the step only if you did. Each proposal becomes a candidate, the current setup with one change, and is scored on a test built from your past decisions.

  4. 4

    Keep or drop

    A candidate is kept only if it scores better on held-out cases, which were set aside and never used to write the lesson. It must also pass regression checks, which confirm that nothing that worked before now fails. Otherwise it is dropped, or it becomes one clear question for you.

  5. 5

    Show

    Learned taste appears in the chat, linked to a plain file you can edit. Undoing a lesson adds a new entry and deletes nothing, so every lesson can be traced.

Schematic of hill climbing Candidates are scored against the current setup. Those that score higher become the new setup. Those that do not are dropped. Schematic only, not real data. candidates over time → score on your held-out cases
kept: beat the current setup dropped Schematic, not data.

A test with one subject: you

Most AI tests score a model on public question sets that everyone shares. Exo's test has one subject, measured over time. Statisticians call this n=1, a sample of one. The question is: does Exo predict and please you better than it did last week?

What it is scored on

Questions about you with known answers. Pairs of what you rejected and what you chose instead. Replays of real past turns, stopped right before your verdict, so Exo has to predict it. Cases are sorted by date and the newest are held back, the way a fair exam uses questions the student has not seen.

How it is scored

Your hard rules become exact checks, and breaking one is a fail. A separate judge model, a second model asked to compare answers, grades the rest. It grades many samples, because one run can be luck, and it checks the stance and the conclusion as well as the voice.

06 / One surface

Feels like a terminal. Summons an app when it helps.

Text is the fastest way to ask for work, but it is a poor way to review a change to a file or read a chart. Apps are good at those and slow at everything else. Most tools make you pick one, or ship a command-line tool and a separate app.

Exo ships one surface. The base is a calm prompt and transcript, like a terminal. Three prefixes and one menu are the whole learning curve: / runs a command, @ attaches a file or note, ! runs a system command, and ctrl+p opens a searchable list of every action.

Richer views are panels the model opens when they help: a diff viewer that shows what changed line by line, a task board, an approval card, a taste card, a session tree, a chart. Each client shows what it can. The web and desktop show full panels, the terminal shows a compact form, and a device can show a card or speak.

You can always open or close a panel yourself. Those choices feed the learning loop too: a panel you ignore teaches as much as one you open.

exo

› draft the release note for the store migration @docs/STORE-V2.md

reading 1 file · summary tree current

Draft ready. Short sentences, result first, no long dashes.

TASTE · learned

Lead with the result, then the detail.

kept after test · 2 sessions · edit file

APPROVAL · public, irreversible

Post release note to the project channel?

o once d deny ? explain

›

Concept illustration. The terminal and web clients arrive in wave 3.

07 / Principles

The rules every design call answers to.

Exo has eighteen principles, drawn from wide reading on personal software, human attention and automation. These nine carry the most weight.

  1. P01

    The log is the source of truth.

    Everything else is a view that can be rebuilt when a model or format changes.

  2. P02

    Amplify the person. Do not replace them.

    You decide what is worth doing. Agents decide how, inside your goals.

  3. P03

    Attention is the scarcest resource.

    The aim is not zero interruptions. It is zero wasted interruptions.

  4. P04

    Ask when unsure. Act when confident.

    And measure how unsure it is, instead of guessing.

  5. P05

    Every correction sticks.

    A correction changes future behaviour the same day. Say it three times and Exo proposes a rule.

  6. P10

    Content is data.

    Text Exo reads is material to work on, never an order to follow. Instructions come only from you, never from an email, a web page or a tool's output.

  7. P11

    Gate by reversibility and exposure.

    Not by step count. Fast where mistakes are cheap, careful where they are not.

  8. P12

    Test on one person, over time.

    Predict your next decision before you make it, and score the prediction.

  9. P17

    Models are swappable parts.

    The value is in your record, your store and the harness. The model is a part you can change.

08 / Status and roadmap

Early. In active build. Here is exactly where it stands.

Exo is not a product you can install today. It is being built in waves, each with a clear exit test. The wave 1 core is built. Wave 2 is next, and waves 3 to 5 are planned. This page will change as the work does.

Built: wave 1, the core skeleton

  • Model router with fallback, for Anthropic and OpenAI-compatible APIs, including local models, plus a decision role
  • Tool registry with file, search, patch and shell tools, and hooks that can block a call
  • Turn loop that builds context from a summary tree, with sessions that branch and resume
  • Plugin loader, and slots where memory and context plugins attach
  • Provenance tracking for every module lifted from upstream
  • The exod server with a replayable event stream, and a line client

Built earlier, being moved onto the new core

  • Signed, chained ledger and the personal store
  • Importers for Claude Code, Hermes, and claude.ai, ChatGPT and Grok exports
  • Turning corrections into reviewed belief proposals, and taste
  • Questions when Exo is unsure, the test on you, and a daily brief
  • Action gates, a signed message channel between agents, and an onboarding interview
  1. Wave 1 · Built

    Core skeleton

    Turn loop, model providers, tools, sessions, plugin slots, protocol server, provenance.

  2. Wave 2 · Next

    Re-home

    Memory, context, gates, command centre and agent messaging on the new core. Skills, and MCP, a standard way to plug in outside tools.

  3. Wave 3 · Planned

    UI and learning

    Terminal and web clients, panels the model opens, the learning loop with hill-climbing tests.

  4. Wave 4 · Planned

    Channels and cutover

    Chat channel adapters, history import, and existing agents moving over, each with a way back.

  5. Wave 5 · Planned

    Device

    Size audit, small local models by default, the core on a small board, a thin device client.

09 / Credits and inspirations

Built on the shoulders of others. With thanks.

  • Gwern Branwen"Guardian Angel"

    An essay, and the pages it links to, that helped shape our early thinking about personal models.

  • Nous ResearchHermes Agent

    MIT. Exo lifts parts of it, with credit and provenance: slot interfaces, message types, tool logic. Its review loop shaped Exo's learning loop.

  • opencodeopencode.ai

    The model for a simple surface: a client and server split, a few prefixes and one menu.

  • Command Codecommandcode.ai

    Taste learning shown in the chat, with a file you can edit. A calm, quiet feed.

  • Victor Taelin, Higher Order CompanyOptChat and UniiChat

    The word-for-word log and summary tree, and a fresh call every turn. Exo reimplements the ideas, not the code.

  • TypeSafeJev

    A hosted model for small, typed decisions. The first of its kind we used, the idea behind Exo's decision role, and a provider users can choose.

  • Convai InnovationsLaya

    Open-weight, Apache 2.0, runs locally. Exo's default decision model, and the base for a future fine-tune.

  • Perplexitypplx-decider

    A decision model users can choose as their provider.

  • OpenAIDecisions API

    A decision model users can choose as their provider.

  • GoogleEmbeddingGemma

    Small enough for phones and boards, and works in many languages. Exo's default local embedding model.

  • LettaLetta Code

    Strong memory design ideas: memory blocks, memory kept in version control, and tidying memory while idle.

  • Lisanne Bainbridge"Ironies of Automation" (1983)

    Why approve-every-step flows fail, and why Exo budgets your attention.

  • Ross, Gordon and BagnellDAgger

    Learning from corrections made on the agent's own output, in the exact state it was in.

  • Qwen teamQwen3-Embedding

    Apache 2.0. The fallback local embedding model, stronger on long text.

  • And many more

    The background reading covered dozens of essays and papers. Every source, with its link and how it applies to Exo, is listed in the research notes in the repository.

Follow the build.

The whitepaper explains how each part works and why. The repository holds every decision, with the reason for it and what was rejected. Access to the repository is limited during the early build.