Open source · MIT · Claude Code & Codex

Your coding agent works while you sleep.

Lea autonomously runs a to-do queue with the coding agent of your choice — Claude Code or Codex. For Claude it waits for your limit to reset, then picks up the next task. Queue work before bed — wake up to it done.

Reset-aware retry loop Sandboxed by default on macOS Keeps your Mac awake overnight
Live demo — add a task and watch the agent work
Lea ready
02:14:30
until your limit resets
62% of window used~38.4k tok/h
Opus812k
Sonnet271k
Refactor the auth module
running~/projects/School
Read src/auth/session.ts
Edit src/auth/guard.ts
Running test suite…
Write integration tests for the API
queuedretries at reset
Security audit of RLS policies
done2:03 AM
For you to do
Apply the migration with supabase db push
Auto-run
The autonomous loop

Queue it tonight. Done by morning.

Lea runs the next task headlessly with your chosen agent, and when the limit is hit it waits and picks up where it left off — for Claude Code, at the exact reset time it reads from your local transcripts; for Codex, on a short retry backoff.

1

Queue your to-dos

Each task is just an instruction plus a project folder. Add as many as you like and leave Lea running.

2

It runs headlessly

The runner takes the first task and runs claude -p or codex exec in an isolated sandbox while you have capacity.

3

Hits the limit? It waits

On a usage-limit, the task is requeued and Lea sleeps until the exact reset time — then retries automatically.

4

Wake up to results

Finished tasks move to Done with full logs, a change report, and a list of follow-ups for you.

Features

Everything you need to run your agent unattended.

Claude Code or Codex

Choose your agent per task — or set a default. Sign in with the CLI (claude /login / codex login) or an API key. Mix both across one queue.

Usage & reset tracking

Live token count, burn rate, value used, and a precise countdown to your next usage-window reset — read straight from your local Claude transcripts via ccusage (Claude Code).

Autonomous task queue

Line up a to-do list of instructions, each scoped to a project folder. Lea works through them one by one, no typing required.

Reset-aware retry

When a run hits the limit, the task goes back to the front of the queue and resumes at the real reset time — looping through your list overnight.

Sandboxed runs

Every run is isolated so an unattended mistake can't wreck your machine. macOS uses a built-in Seatbelt sandbox that confines writes to the project folder.

Keeps your computer awake

Prevents sleep — but only while tasks are pending — so overnight runs actually happen instead of stalling on a sleeping laptop.

Follow-ups for you

When a task needs something only you can do — push to a remote, apply a migration, rotate a key — Lea surfaces it and fires a desktop notification.

Per-task change reports

Each run writes a snapshot diff of what was added, modified, and deleted into Lea_Reports/ in your project — so you can review before trusting it.

Per-model breakdown

See exactly how your window is split across Opus, Sonnet, and Haiku, with live bars and token totals per model.

Chat & reply on a task

Pick up any finished task and keep going — Lea continues the agent's own session (Claude --resume / codex exec resume), so context is preserved.

Efficient "away" mode

Switch to a cheaper model when you're idle or asleep, plus live progress streaming so you can watch what the agent is doing in real time.

Download & install

Up and running in four commands.

Lea is open source. Clone it, install, and start — a small ring icon appears in your menu bar.

Terminal — install from source
# 1. Clone the repo
$ git clone https://github.com/bobby33400/Lea.git
$ cd Lea

# 2. Install dependencies
$ npm install

# 3. Launch the menu-bar app
$ npm start
Quick start. Download Lea and sign in to your agent once — Claude (claude/login) and/or Codex (codex login). On first launch Lea asks which agent to use and how to sign in; then it runs normally.
Or let Claude install Lea for you. Open claude in any folder and paste this — it clones, installs, and launches for you.
Paste into Claude Code
# Paste this to the claude CLI
Clone https://github.com/bobby33400/Lea.git into this
folder, run npm install inside it, then start
the app with npm start. If anything fails,
fix it and try again.

Requirements

  • macOS, Windows, or Linux with Node 18+.
  • At least one agent CLI, signed in: the claude CLI (claude /login) and/or the codex CLI (npm i -g @openai/codex, then codex login). API keys work too.
  • Docker (optional) — only if you want sandboxed runs on Windows or Linux.
Lea uses your own Claude and/or OpenAI account and respects your own limits. It is not a separate subscription.
Prefer a prebuilt installer? Pushing a v* tag (or running the GitHub build workflow) produces a .dmg/.zip for macOS, an .exe for Windows, and an .AppImage for Linux. Or build one locally with npm run dist.
Windows: app won't start? Electron's npm package downloaded, but its actual program file (the Electron .exe) is missing or corrupted. Most likely cause: your project is inside OneDrive, which interferes with node_modules files.
Fix — reinstall Electron (run in your Lea folder):
npm.cmd uninstall electron
npm.cmd install electron
npm.cmd start
If it still fails, move the project out of OneDrive and reinstall:
Move-Item "<your-OneDrive-path>\ClaudeProjekte" "C:\Dev\ClaudeProjekte"
cd C:\Dev\ClaudeProjekte\LEA\Lea
npm.cmd install
npm.cmd start
Safety model

Unattended agents are powerful — and risky.

Headless runs never block on a prompt (Claude uses --permission-mode bypassPermissions; Codex runs non-interactively). That's exactly why isolation matters — and why Lea defaults to the safest option for your platform and agent.

macOS — Seatbelt sandbox (default)
Built in. Zero setup.

Claude runs are wrapped in sandbox-exec — file writes are confined to the project folder; ~/.ssh, ~/.aws, and Keychains are hard-blocked. Codex brings its own sandbox (--sandbox workspace-write), so it's confined the same way without a wrapper.

Windows / Linux — Codex self-sandboxes; Claude via Docker
Codex confines itself; Claude needs Docker for isolation.

Codex uses its own sandbox (Landlock). Claude runs directly with a warning unless you enable the bundled Docker backend, which mounts only the project folder writable — docker build -t lea-claude:latest docker/ (or -f docker/Dockerfile.codex -t lea-codex:latest).

Please start small. Begin with low-stakes tasks and review the logs before trusting Lea with anything important. Use per-project git commits so every change is reversible.
Configuration

Tune it from the Settings panel.

Every default is adjustable — click any value to open it and choose from the options Lea gives you.

SettingDefaultWhat it does
Auto-run Master switch for autonomous execution
Default agent Runs new tasks unless a task picks another agent
Sandbox backend Seatbelt on macOS, none elsewhere — or force Docker / none
Keep computer awake Prevent sleep while tasks are pending
Quiet hours Pause auto-run during a chosen time window
Default model Per-agent model used when a task doesn't specify one
Task timeout Kill a task that runs too long
Max retries Retries for non-limit errors
Token budget / block Pause after N tokens per usage window
↳ These mirror the in-app Settings — pick a value above to preview your choice.

Let your agent work the night shift.

Free, open source, and yours to inspect. Clone it and queue your first task tonight.