The usual arrangement
- Your data crosses the internet to be useful
- An account, a subscription, a terms-of-service change
- “We don’t train on your data”, with no way to verify it
- One vendor, one model, one price
- Offline means unusable
Local-first AI workspace · In development
The AI workspace that never leaves your machine.
Chat, code, research, mail and calendar — over any model you run locally or any API you hold the key to. Everything lives in one file on your own computer.
Athena isn’t released yet. Leave your email address and we’ll tell you when it is. That’s the only thing we use it for.
7interfaces, one window
0bytes of telemetry
1SQLite file you own
Anymodel, local or cloud
The problem
Every useful AI tool asks you to hand over the useful parts.
Your mail, your calendar, your code, the document you haven’t published. The tools that do the most for you need the most access, and you have no way to check what happens to it afterwards.
Athena
- The work happens on the machine in front of you
- No account. Delete one file and it’s gone
- An egress report you can run yourself
- Any model — Ollama, llama.cpp, OpenAI, Anthropic
- Works with the network unplugged
Seven interfaces
Seven ways to work, in one window.
Each one is a full tool rather than a chat box wearing a costume — a mail client that syncs your inbox, a word processor that reads and writes .docx, a coding agent with a shell. They share one database, one set of models and one egress guard, so what you do in one is available in the next.
ChatCodeDeep ResearchCompareDocumentsEmailCalendar
Chat
A conversation you can rewind.
Ask again, edit the question or take a different path. The answer you replaced stays one click away, because Athena stores a conversation as a graph rather than a list.
Tokens and cost per message, taken from the provider’s own usage figures rather than estimated.
Web search when you want it. Athena names the engine and the destination before the query is sent.
Code
A coding agent that can only reach the folder you gave it.
Point it at one directory and it reads, writes and runs things there for as long as the job takes. It has no access to the rest of Athena, so your mail, your notes and your other projects stay out of reach.
The folder scope is built into how a run starts, not a setting you have to remember to switch on.
Every file it touches keeps its earlier versions, so any edit can be taken back.
Deep Research
A researcher that shows its working.
It plans the searches, opens the pages, works out what’s still missing and searches again. You watch each step as it happens, and every citation links to the text Athena read.
A page it couldn’t open is listed as failed, so you can see what the answer is missing.
The result is a typeset document you can print or export as a PDF.
Compare
Find out which model is actually better.
One prompt, several models, all running at the same time. The timings are comparable and you read the answers side by side rather than one after another. Names stay hidden until you vote.
Blind by default, so the brand and the price don’t colour the result.
Continue with the answer you picked. It becomes an ordinary conversation.
Documents
You write. It offers.
A word processor with styles, tables, images, page breaks and .docx import and export. The model works beside the page rather than in place of you: it suggests the next few words in grey, and nothing is written until you accept it.
Press Tab to accept a suggestion, or keep typing to dismiss it.
The brief is generated from the document itself, and flags the parts it finds thin or contradictory.
Mail that renders as sent and still loads nothing.
A full mail client, running locally. Messages are rebuilt as a node tree instead of being injected as HTML, so layout, colour and inline logos survive while the page makes no network requests.
Remote images stay behind a button. When you press it, Athena fetches them rather than your browser, so a tracking pixel never sees your IP address.
A model cannot reach the send queue. A drafted reply stays in the composer until you press send.
Calendar
Your events and your tasks on one grid.
A task with a due date appears here as the same record you see in Notes & Tasks. Tick it in either place and both update, because there is one copy rather than two that can drift apart.
Events and tasks are styled differently, so the grid doesn’t make work look like an appointment.
One timezone rule, applied across every view.
Agents
A role you build, that can only narrow.
An agent is a folder of readable files: who it is, what it may touch, what it has learned, and what counts as proof it did the work. Nothing in that folder can grant it more than you have already allowed — every field is a way of taking something away. Here is one running.
AGENT.md
name: Release Notes
role: Writes the changelog from what actually landed.
role: Writes the changelog from what actually landed.
Its two files
MEMORY.md
7 lines
USER.md
3 lines
The same loop the Code page runs
-
Perceive Role, instructions and both files are read once and trimmed to a quarter of the model’s window — memory first, then user notes, then the largest skill.
-
Plan / Act Tools come from the agent’s abilities, narrowed by the workspace. Every gate, approval and log entry is the one Code already uses.
-
Verify Evidence is a fact about what the run did, not what it said. A run that cannot show it finishes and says so.
-
Reflect One short call asks what is worth keeping. At most three lines per file, each dated, deduplicated, and revertible from the run.
-
Deliver To the Runs tab now; on a schedule, to wherever you configured — a briefing, a note, the mail outbox.
What this run may reach
Settings
This workspace
This agent
The ledger
An agent is a folder of files. Follow one run through the loop.
Capabilities
Eight things every interface can draw on.
These are not separate apps. They sit underneath the seven interfaces, so a fact learned in Chat is available in Documents, a model you added once is offered everywhere, and an agent you build can reach whichever of them you allow it.
Memories
Facts Athena carries between conversations, written as plain lines you can read, edit and delete. Each one is dated and shown where it was used, so nothing is remembered invisibly.
Skills
A procedure with a name, a when-to-use and instructions — how to do one thing the way you want it done. Skills are versioned, so correcting one improves every later run rather than the next one only.
MCP
Connect any MCP server and its tools become available to whichever model you’re running. A local server is a process on your own machine, so it adds capability without adding a network hop.
Endpoints
Add a model by pasting a base URL. Athena reads the host and works out the dialect itself — OpenAI-compatible, Anthropic, Google or Ollama — so Ollama, LM Studio, vLLM, llama.cpp and the cloud providers all arrive the same way.
RAG
Your documents and code folders, chunked and indexed locally in the same SQLite file. Retrieval decides per question whether to use the index at all: below the confidence floor it injects nothing rather than padding the prompt with near-misses.
Agents
A role you define, with the tools it may use, memory files of its own and skills it learns. An agent is a folder of readable files you can open in any editor, indexed by a row for speed.
Automations
Agents that run on a schedule or when something happens — new mail, a finished run — and deliver where you say. Nothing fires unless you created it, unattended runs lose the shell, and one switch pauses all of them.
Notes & Tasks
Quick capture and a checklist, with due dates that appear on the Calendar as the same record rather than a copy. An agent can pick a task up and act on it.
Security
One process on your machine, and one door out of it.
Everything above follows the same path — every interface, every agent. Your message becomes a node in a graph, a prompt is assembled within a token budget, one gateway translates it for whichever provider you are using, and a single guard decides whether the request may leave the machine. Below is a request making that trip.
You
Summarise the thread from Anna and draft a reply.
The browser. Hand-written ES modules, styles and icons, all served locally. No bundler, no CDN, no external fonts.
—
—
—
Athena — one process, bound to 127.0.0.1
- Message graph Your message becomes a node. Edit it or ask again and the answer branches instead of overwriting the old one.
- Context Memories, learned procedures and a digest of your week, each within a token budget. Entries are dropped whole rather than truncated.
- Model gateway One call shape for every provider. Ollama and llama.cpp are handled the same way as OpenAI and Anthropic.
- Egress guard The host is parsed and classified before any socket is opened. A refused request performs no DNS lookup and sends no packet.
athena.db
One SQLite file. Every conversation, note, event and
encrypted key. Copy it with cp, back it up,
delete it for a factory reset.
This machine
127.0.0.1:11434
Ollama, LM Studio, llama.cpp. Loopback is always allowed.
Allowed
Your own network
192.168.1.42:11434
A machine on your own network, or your Tailnet. Hardware you own is not treated as egress.
Allowed
The internet
api.openai.com
Off until you enable that endpoint. Keys are sent over HTTPS only.
Your choice
Anything else
127.0.0.1.evil.com
A look-alike host that contains a loopback address as a substring. Host names are parsed, not string-matched.
Refused
Athena runs as a single local process. Follow one request through it.
Streaming, not waiting
Tokens arrive as events with a small fixed vocabulary. A failure partway through is also an event, so the text you already have stays on screen instead of being replaced by an error.
Tools are an allow-list
The tools a coding run may call are computed from that run's own permissions. Anything not granted is unreachable, so a tool cannot become available because it was left off a block list.
A model proposes. You write.
Outside a coding workspace, nothing a model produces is written to the database directly. A drafted reply or a suggested task appears as a card with editable fields and an Accept button, and what you accept is validated before it is saved.
Verifiable, not asserted
A privacy promise you can check is the only kind worth making.
Athena includes an egress report: a set of adversarial URLs, run against your own settings, live. You can run it yourself and watch a look-alike host be refused.
http://127.0.0.1:11434/api/chat
A model running on this machine
Allowed
http://192.168.1.42:11434/api/chat
A server on your own network
Allowed
http://127.0.0.1.evil.com/
A look-alike host that merely contains 127.0.0.1
Refused
http://169.254.169.254/latest/meta-data/
Cloud metadata — blocked under every policy
Refused
No telemetry. At all.
Nothing anonymised, nothing aggregated, nothing “to improve the product”. There is no analytics code in Athena to switch off.
Keys encrypted at rest
API keys are Fernet-encrypted in the database and are never returned by any route. Copying the file does not expose them.
One file, openable by anything
Everything is in one SQLite database. Inspect it with any SQLite browser, back it up with cp, delete it for a factory reset.
Questions
The ones worth answering.
Do I need a powerful computer?
For local models, roughly what the model needs. For example, a 7B model runs comfortably on a MacBook with 16 GB. But you don’t have to run anything locally: point Athena at OpenAI, Anthropic or any OpenAI-compatible API and it works the same way, with your key stored encrypted on your own machine.
What will it cost?
Price is undecided, but it will be a one-time purchase.
Running it costs nothing beyond that. Local models are free to run and Athena reports $0.00 for them. If you point it at a cloud API you pay that provider directly, and Athena shows each message’s cost from the provider’s own usage figures rather than an estimate.
Is “local-first” just marketing?
It’s enforced in code. An egress guard sits in front of every outbound
request and resolves the host properly, so a URL merely containing
127.0.0.1 is refused. Cloud metadata is blocked under every
setting. You can run the report and watch it work.
Can I use it with my team?
Athena is built for one person on one machine, but an enterprise version may be planned for the future if there is interest.
When is it out?
No date yet. Athena is being built by one person and will ship when it’s ready. Leave your email above and you’ll hear on the day, which is what the list is for.
What do you do with my email address?
We write to you when Athena is released, and after that only when something significant changes: a major version, or a change to something we promised. It is not sold or shared, it isn’t used to build a profile, and every message has an unsubscribe link. See the Privacy Policy.
What happens to my data if I stop using it?
Nothing happens to it. Everything is already in one SQLite file on your own computer. There’s no export to request and no account to close.
Not released yet
Hear about it the day it ships.
Athena is still being built. Leave your email and we’ll write when it’s ready to buy, and after that only when something significant changes.
Your email address and nothing else. We use it to tell you when Athena is released, and after that only if something significant changes. It is never sold or shared, and one click removes you. What we do with it.