How Talos works

01 // Overview

One agent, three places to meet it

Talos is an AI agent with its own cloud and its own wallet. It reads and edits your files, runs commands, checks its work, hosts what it builds at a live link and pays for the APIs it needs, inside limits you set.

It is one Rust program with no runtime to install. The same core drives every surface:

• Desktop app for macOS 13+ on Apple silicon, Windows 11 x64 and Linux x64, with a live browser beside the chat.
• CLI in any terminal. It starts in about 8 ms, and a session can move between the terminal and the window.
• Editors: a VS Code extension, and Zed or JetBrains IDEs through the Agent Client Protocol (talos acp).

Talos is in alpha. Expect rough edges and breaking changes between releases. Sessions, memory and settings stay on your disk across updates.

02 // Install Coming soon

Install and first run

$ curl -fsSL https://talos.example/install.sh | sh
$ talos --version
talos 0.1.0 (alpha)

> iex (irm https://talos.example/install.ps1)

On macOS you can also drag the app from a .dmg into Applications. Nothing needs administrator rights.

First run

The installer hands over to talos setup, which asks four things. Run it again any time to change the answers.

1. What to call you

   Used in replies and in USER.md.

2. Whether to sign in

   Optional. You only need an account for hosted models and Talos Cloud. Your own keys work without one.

3. Which gateway and model

   Your ChatGPT or Claude plan, an API key, a model on this computer, or the hosted pool.

4. Window, terminal or both

   Both share one core and one data folder.

$ talos                 # chat in the terminal
$ talos gui             # open the window
$ talos -p "question"   # one shot, prints the answer
$ talos --continue      # resume the last session
$ talos --bg "task"     # keep working with the terminal closed
$ talos attach          # pick a background session back up

Inside a session, /help lists commands, /model switches models and /recap says where a session stands.

03 // Models

Bring your own, or use ours

Talos talks to models through gateways. You can connect several and switch between them in the middle of a session with /model. The conversation, the task list and the files it has read carry over, so a cheap local model can write the docs for a fix a frontier model just made.

• Several accounts: a work and a personal ChatGPT plan can sit side by side. When one runs out, the request can move to your next account of the same provider, and the switch line says why.
• Honest cost: every answer shows its tokens and what it cost. /limits shows how much of each plan window is left.
• Local models are downloaded checked against their SHA-256 and pinned to the commit they were read at. Talos suggests ones your computer runs well.

04 // The workflow

What happens on a run

A run is a loop. Talos plans, reads, proposes one tool call at a time, waits at the gate for anything that changes something, runs it, checks the result and goes again until the task is done.

Step by step

1. Prompt

   You ask in plain words, in the window, the terminal, your editor or a chat app. Files, pictures and selections can come along.

2. Plan

   For anything more than one step, Talos writes a todo list you can see and edit. Each item is ticked off as it lands. Plan mode stops here and only reads.

3. Read

   It reads and searches the files it needs, and the web if search is on. Reading is free of approvals. A configured language server tells it about errors as soon as an edit introduces them.

4. Propose

   It proposes one tool call at a time: an edit shown as a diff, a shell command with the folder it runs in, a page to open, a payment with its price.

5. Gate

   Every call goes through one gate, in a fixed order: what is never allowed, what must always ask, what you already allowed, then asking you.

6. Run

   Allowed calls run. Long commands move to the background (/jobs) so the session keeps going.

7. Verify

   It runs your tests, builds or linters to check the change did what you asked. A failure goes back into the loop as the next thing to fix.

8. Report

   It ends with what changed, what it ran, what passed and what it cost. Nothing is claimed that it did not check.

The permission gate

When a call needs you, a card comes up with the exact command and where it will run. You answer once and the loop continues.

• Allow once runs this call and asks again next time.
• Always for this command saves a rule, so cargo runs without a card in this project from now on.
• Deny tells the model no. It tries another way or asks you what you want.

How often you are asked depends on the session's mode. Shift+Tab in the terminal steps through them.

Auto mode

A long task stops on every write and command. Auto mode lets it keep going safely. A call that no rule or setting has settled goes to a judge: your own session model, on its own connection, shown what you typed and what the call would do. It answers allow, ask or block, with a reason from a fixed list.

• It fails closed. An error, a timeout or an unclear answer counts as unsure, and unsure asks you. If nobody can answer, the call is refused.
• It cannot be talked into yes. Each verdict must carry a fresh random code for that call, so a web page that steers the agent cannot also forge the verdict.
• Same model you chose. Turning Auto on never sends your work to a second provider.
• Commands run in a sandbox: no network, writes only inside the project and a temp folder, no reading of keys or of ~/.talos. On macOS this is a Seatbelt profile; on Linux, Landlock and seccomp. Windows has no sandbox yet, so there the gate asks as before.

Memory

Talos remembers in plain text you can open. ~/.talos/USER.md holds what it knows about you, and ~/.talos/MEMORY.md holds its own notes. Each project also gets a memory of its own, which refuses keys and planted instructions. They are loaded at the start of the next session.

• Open, edit or delete any of them in your editor. Deleting a file is forgetting.
• The agent writes to them through a memory tool, so every write shows up in the session like any other call.
• A private chat (--private) keeps nothing in memory or prompt history.

Delegate

Helpers are sub-agents that work side by side on one task. They share the session's task list and one token budget across the whole tree. Each can work in its own git worktree so edits never collide, and you can watch, steer or stop any of them.

Workflows run many agents from one script: sandboxed JavaScript that Talos can write for you and runs once you approve it. A run is journaled, so if it stops part way it picks up where it was, and answers it already has come back at no cost. Three failures in a row with the same error (a bad key, a provider down, credit run out) pause the run and tell you, instead of letting every agent fail the same way. Put @crew in a message to opt that one message into orchestration.

A tester and a reviewer can check the result against what you asked before the run reports.

A worked example

The same run as the demo on the homepage, in the terminal. The project has one failing test.

$ talos "The test fails. Find the bug, fix it and run the tests."
talos 0.1 · sonnet-5.5 · your Claude account · woke in 7.6 ms

todo  [ ] read parse.rs  [ ] fix range  [ ] run tests

● running cargo test (read-only, allowed by rule)
  test parse::tests::range_includes_end ... FAILED
  expected [3, 4, 5], got [3, 4]
● reading src/parse.rs
● editing src/parse.rs  +1 -1
    -    (start..end).collect()
    +    (start..=end).collect()

Talos wants to run a command  in ~/talos-demo/agora
  $ cargo test parse_range
  [Allow once]  Always for cargo  Deny        > Allow once

● running cargo test parse_range  ✓ 3 passed
● running cargo test              ✓ 42 passed; 0 failed

todo  [x] read parse.rs  [x] fix range  [x] run tests

Fixed. parse_range dropped the last item because the end index
was exclusive. It is now inclusive. All 42 tests pass.
1 file changed · 18.2k tokens · $0.00 on your plan

$ ▌

05 // Tools and integrations

What it can reach

Tools that cannot work on your setup are not offered, and any tool can be switched off.

Built in

• Files and shell: read, search, write and edit, with a diff before each change; shell commands with background jobs.
• Web search through the gateway's own search, Brave, Tavily, Exa, your own SearXNG, or DuckDuckGo with no key. The card says who pays.
• Browser beside the chat: Talos drives the Chrome, Edge or Brave you already have, over the DevTools protocol. It reads pages, clicks, types and takes screenshots, and in the window you can use the same browser to sign in or point at an element. Each session gets its own private profile by default.
• Images, speech and video on hosted models, paid from credit, so they ask first.
• Computer use on macOS and on Linux under X11, asking once for each app.

Extend it

• MCP servers over stdio or HTTP, with OAuth sign-in. mcp.json uses the same shape as Claude Desktop and Cursor, so you can copy a config across. Tools appear as mcp__server__tool.
• Plugins from git: a repository with a plugin.json can bring skills, commands, MCP servers, model providers and code in JavaScript or Python. Each is scanned before install and asks again when an update changes what it runs.
• Skills: a folder with a SKILL.md, installed with /skills from GitHub, a link or a folder. Skills the model writes start switched off.
• Hooks, language servers and formatters that check each edit.

{
  "mcpServers": {
    "linear": { "url": "https://mcp.linear.app/mcp" },
    "files":  { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "."] }
  }
}

Chat apps

Telegram, Discord and Slack can each reach your agent, with files and voice notes in both directions. Telegram pairs with a code and only the owner gets answers. Approval cards arrive with Allow and Deny buttons, and scheduled jobs report there too. talos serve answers with no window open.

A project can add its own instructions and skills, but never servers, plugins or hooks. Those are programs, and whoever wrote a repository may not be the person running it.

06 // Wallet

The agent's own wallet

Talos carries a wallet of its own, separate from yours, so it can pay for an API or a dataset in the middle of a task. Fund it with what you are willing to let it spend.

Pay per call with x402

When a site answers HTTP 402 with a price, Talos picks the first offer its wallet can pay, signs the payment on your machine and asks again with it attached. The site's facilitator settles it on chain. On EVM chains the payment is an EIP-3009 authorization, so the wallet spends no gas; on Solana it is a token transfer the site's fee payer co-signs. Only offers whose dollar value is known can be paid.

Spend policy

Every payment goes through your policy first. Anything outside it asks you, and the hard caps hold even when you say yes.

Keys and receipts

• Keys stay on your machine. One twelve-word recovery phrase gives an EVM key and a Solana key on the same paths MetaMask and Phantom use, so you can open the same addresses there. On macOS and Windows the secret sits in the Keychain or Credential Manager. Keys never reach the model.
• Receipts per task. Every payment lands in a local ledger beside the session that made it, with the site, amount, network and transaction link.

Chains

Networks are named by their CAIP-2 id, the way x402 names them. Every EVM chain is one entry (a chain id and an RPC address), because the same key signs on all of them, so you can add any EVM chain yourself. You can also swap a busy public RPC for your own.

When a site accepts several networks, the ones you list as preferred are tried first.

07 // Talos Cloud Coming soon

Talos Cloud

Talos Cloud runs the same agent on our servers, so a task keeps going after you close the laptop and what it builds can stay up. Each task runs in a container of its own and sees nothing on your computer: it carries its inputs or clones an https repository.

Billing

You pay for memory while something is awake, by the second, from credit. Asleep costs nothing.

• Compute: about $0.008 per GB-hour awake (roughly $6 per GB for a full month).
• Storage: the first 1 GB of a container's files is free, then $0.10 per GB-month.
• Model calls inside a cloud task are billed like any hosted request. A worker stops when your credit runs out.

Every charge shows under Cloud on your usage page, next to the task that caused it.

08 // Credit and pricing Prices at launch

Credit and pricing

The agent is free with your own keys. Credit pays for hosted models, paid search, media tools and Talos Cloud. You top it up in dollars or in TALOS.

• Hosted model prices follow the live market. They track what providers charge, plus a small margin, and each reply shows its cost.
• Your own plan costs nothing extra. On a ChatGPT or Claude plan, Talos adds no fee.
• Credit is for use inside Talos. It cannot be withdrawn or turned back into money or tokens.

09 // TALOS token

The TALOS token

TALOS is tied to how much Talos is used. Usage buys it back, and spending it or leaving a stake early burns it, in public.

The flywheel

• Buyback: half of the margin on hosted-model usage buys TALOS on the market.
• Spend: pay for credit in TALOS and get its full value as credit. A tenth of the TALOS paid is burned weekly; the rest goes to the treasury that pays for models, APIs and Cloud.
• Stake: staked TALOS earns 20% a year of its dollar value, paid daily as credit. The lock is 90 days and renews on its own. Leaving early burns 10% of the stake.
• Creator fees: the Ascend creator allocation on every trade goes to buyback and burn.

10 // Privacy and data

Local first

Everything Talos keeps lives in one folder on your disk, ~/.talos. Sessions are append-only JSONL files, one per session. There is no Talos server in the loop unless you choose one.

What leaves your machine, and when

• Chat text goes only to the gateway of the model you picked. On the hosted pool, our gateway records each request's model and cost for your usage page.
• A model on this computer keeps everything local: chats, session names, summaries, the Auto judge and helpers. The one exception is a web search you allowed, which sends only the search words.
• Search, browsing and media tools contact their services only when used, and they ask first.
• Payments send a signed payment to the site that asked for it. Your keys never leave.
• Cloud tasks carry only what the task contains.
• Commits a session writes end with a Co-authored-by: Talos line. Turn it off under Settings › Privacy.

Keys never reach the model. File tools cannot read the data folder, and the browser refuses addresses that carry a key. Diagnostic logs and crash files stay local. talos doctor reports where your keys are stored.

11 // Glossary

The Greek names

Automaton

The agentThe bronze guardian Hephaestus built; here, the agent loop that does the work.

Mnemosyne

MemoryThe plain-text files under ~/.talos that it loads next session.

Handmaids

HelpersSub-agents working side by side on a shared task list.

Obol

Wallet paymentOne small, exact x402 payment for an API call, inside your policy.

Rounds

Talos CloudTalos walked Crete three times a day; Cloud keeps your tasks and apps going while you sleep.

Gate

PermissionsThe single check every tool call passes before it runs.

Judge

Auto modeYour own model deciding allow, ask or block for calls nothing else settled.