Who holds the AI that knows you? Your machine. Your models. Your data.

Compare

Grok Bot, Muse and Today are all doing the same thing: moving into your life and acting before you ask. The only difference is how many apps each one plugs into. The cost is the same: the thing that knows you lives at their house.

What it is

eta is a workbench for always-on agents. It runs on your own machine and you use it in the browser, on desktop or phone. Not a session — a team that stays.

• Always-on agents Each has its own name, instructions, persona card and model. A restart loses nothing, and it remembers where the last turn stopped.

• Group chats and a steward Several agents in one conversation; whoever you @mention answers, anything unmentioned goes to the steward.

• Task board An agent proposes a task, you confirm it, the agent does it in its own session and hands it back for review.

• Routines A short session on a schedule that leaves a report — and says nothing when there is nothing new.

• Memory It remembers what was said; you can browse, search and delete. Memory is rows in a database, not a mood.

• Artifacts Agents publish static pages: reports, charts, prototypes. Preview, share, revoke.

• Your own models 100% BYOK: a subscription account, an API key, the private model in your own rack — all of it counts.

Fig 1. process: no cluster, no message queue

1

Fig 2. SQLite file holds conversations, tasks, memory, usage and settings

1

Fig 3. external services required — it starts without a network

0

Fig 4. of the source is in your hands, short enough to read

100%

Agents

Agents are who you talk to and hand work to: a name, instructions, a persona card, a model, and which bundles it may use. Not a session, and not a machine.

Tasks

An agent proposes a task in the conversation; once you confirm it, the agent runs it — a worktree in the project, then back to you for review. You see every step, not a "done".

· list_tasks
· get_task
· update_task
· comment_task
# report done and hand it back for review
· finish_task
# merging is a click you make, not it
· open_pull_request

A session runs on its machine, as your user, with whatever the tools are allowed to do. Only attach machines you keep for work.

Routines

Something that does one thing on a schedule. There is no agent behind it — only a model, a brief and a clock. Each run either reports or says nothing.

Control

Control first. You can see what an agent is doing, stop it, change it. Anything that needs your OK waits as long as it takes.

# built in, shipped with the source
- id: gh-pr-create
  on: shell_exec
  checks:
    - argv: [gh, pr, create]
  message: Push the branch, then open the PR with open_pull_request.

# brought by a bundle’s akhook.yml
- id: confirm-push
  on: shell_exec
  action: ask
  checks:
    - argv: [git, push]
  message: A push needs your OK.

Bundles

A bundle is a directory: skills, MCP servers, hook rules, and optionally a service. Whatever an agent ticks, its sessions carry on whichever machine they run. No repackaging, no install scripts.

my-bundle/
├── plugin.json       # name, description, requires, config, service
├── mcp.json          # stdio or streamable HTTP
├── skills/*/SKILL.md
└── akhook.yml        # tool-call rules

Models

The models are yours. Pick one: link a ChatGPT (Codex) or Grok subscription with a device code, paste a Google AI Studio key, or point it at any OpenAI-compatible service — including the one in your own rack.

Architecture

Everything is in one process: the web, product data, running sessions, model credentials. No control plane, no message queue.

Data

Conversations, tasks, memory, artifacts and agent workspaces all live on your machine, in one directory. The only thing that leaves is what you send out.

Deploy

One machine is enough. One process, one data directory, one SQLite file. Decide before you start which machine the data lives on.

1. 01

   Run the process directly

   recommended

   git clone \
     https://github.com/0xfe-project/eta.git
   cd eta
   bun run setup
   bun run --cwd apps/web build
   HOME=/var/lib/eta bun apps/eta/src/main.ts \
     --web-dir apps/web/dist \
     --host 0.0.0.0 --port 8787

   Copy

   The data directory is always $HOME/.eta — no flag moves it: change HOME instead. In systemd that is Environment=HOME=/var/lib/eta.

2. 02

   It closes the door on its own

   token gate

   Listening beyond loopback turns the token gate on: every request except /up needs a token. Open /?token=<token> once in a browser and it sets a cookie (HttpOnly, SameSite=Strict, 30 days); scripts use Authorization: Bearer. Behind a proxy, pass --allow-origin with the page’s public address.

3. 03

   Link your own models

   Settings → Model services

   A subscription account (device code), a Google AI Studio key, or any OpenAI-compatible service — pick one, or all three. A model you host only needs an address and a key.

4. 04

   Add another machine

   optional

   # Settings → Machines → Add, copy the command it gives you
   eta-daemon setup <primary-url> <code>
   eta-daemon run
   eta-daemon install-service

   Copy

   The daemon is a single file with no web and no database: sessions run there, product data and model calls stay on the primary. The code works once and expires in 24 hours; you approve the pairing after checking the fingerprint. install-service registers a systemd user service or a launchd agent.

FAQ

Principles

eta’s interface is built on these rules. So is this page.

1. 01

   Control first

   Using it should feel like things are in your own hands. Calm is there only so nothing knocks you out of that state.

2. 02

   Stay in flow

   The aim is to keep you in flow — and let you stay inside the work.

3. 03

   Ablate

   Try removing every element. If nothing is lost in understanding or use, it doesn’t stay.

4. 04

   Dashboard dense

   Use space like a car’s dashboard. Density is respect, not clutter.

5. 05

   Right angles

   Square corners everywhere. Every colour goes through a variable; light and dark both.

6. 06

   60ms linear

   Interaction transitions are 60ms linear: no trailing, no bounce. Reduced motion is respected.

7. 07

   Plain words

   Agent and technical parts use everyday words so you know what’s going on. No piles of jargon.

8. 08

   Finish it

   Polish means alignment, spacing, states, feedback and motion are all done — not a more “professional” skin.