Alera

The native, performance-first agentic development environment.
Run Claude Code, Codex, Grok Build, Amp, Antigravity, OpenCode, Copilot, Cursor or any other CLI agent side-by-side, each in its own Git worktree, all tracked in one place.
Built with Flutter + Rust + Ghostty. No Electron. No bundled Chromium. Available for macOS, Windows, and Linux.

Get Alera →  ·  alera.build  ·  Roadmap

---

Why Alera

Agentic coding is the new bottleneck of developer tooling. Most "AI IDEs" today wrap a single chat backend inside an Electron shell: slow to start, heavy on RAM, locked to one provider, and limited to one task at a time.

Alera takes the opposite bet:

• Bring your own agent. Alera is terminal-first. Every CLI coding agent runs in its own real PTY, the way it was meant to. No proprietary chat layer, no vendor lock-in
• Run many agents at once. Each task gets its own Git worktree, its own tabs, and its own terminals, so Claude, Codex, Amp, and friends can work in parallel without stepping on each other
• Native performance. Flutter for a fast, consistent desktop UI. Rust for the PTY and process layer (portable_pty). Ghostty's VTE engine for terminal parsing. No Electron, no embedded browser, no JS event loop in the hot path
• See what your agents are doing. Lifecycle hooks for the most popular CLI agents stream their activity into Alera so you can tell, at a glance, which terminals are idle, working, or waiting on you
• Take attention with you. Optional Alera accounts and Firebase push can notify a subscribed phone when an agent waits, blocks, or reaches an orchestration decision, even after the desktop UI closes
• Track agent quotas. A bottom status bar shows local or remote quota usage for Claude Code and CCS profiles, Codex, Kimi, Grok Build, Antigravity, MiniMax, and Z.ai
• See what they cost. A Resource Manager in the status bar attributes live CPU and memory to each project, workspace, and terminal tab, so you can tell which agent is eating the machine
• Never lose a terminal again. Terminal sessions persist across restarts. Close the app, reboot the machine, come back, and your scrollback, processes, and layout are still there

---

Supported CLI agents

Alera works with any CLI agent. The agents below ship with first-class integration today (icons, managed lifecycle hooks, and live activity tracking):

Claude Code   Codex   Amp   Antigravity (Agy)   OpenCode   Cursor   GitHub Copilot   Pi Grok Build

Anything else that runs in a terminal (Gemini CLI, Goose, Kimi, Crush, Continue, Aider, your own scripts) works out of the box. Activity tracking is incrementally rolling out per agent.

---

What you get today

Alera is in active development. These are the features shipping right now:

🗂️ Project & workspace registry

Register existing local folders or clone Git repositories from one place. Git-backed projects can spin up multiple workspaces backed by real Git worktrees: create a branch from a source branch or reuse an existing local branch, one task or experiment per workspace, fully isolated.

🌳 Worktree-native workflow

Every workspace is a worktree. Less branch juggling, fewer "wait, what was I working on?" moments. Switching contexts is instant, and your agents never collide on the same files.

🤖 Multi-agent terminals

Open multiple terminals per workspace, organised in tabs. Run Claude Code in one, Codex in another, Amp in a third, all in parallel and all visible at the same time. Each terminal is a full PTY backed by Rust (portable_pty) and parsed by Ghostty's VTE.

📡 Live agent activity tracking

Managed lifecycle hooks for Claude, Codex, Grok Build, Amp, OpenCode, Antigravity, Cursor, Copilot and Pi stream agent events into Alera. You can see which agents are idle, working, or waiting on input without staring at every terminal.

📊 Agent quota tracking

A bottom status bar keeps provider quota usage in sight while agents run: Claude Code and CCS profiles, Codex, Kimi, Grok Build, Antigravity, MiniMax, and Z.ai, resolved locally or remotely. Hover for the detailed breakdown, and know before an agent stalls that you're about to hit a limit.

🧮 Resource Manager

A status-bar chip opens a panel that attributes live CPU and memory to Project → Workspace → Terminal tab, with memory sparklines, Alera's own app and sidecar rows, and machine memory and load for context. Terminal sessions the host still holds but no tab claims are listed as orphans and can be killed in one click. Sampling runs in the Rust sidecar and only while something is watching.

🕸️ Inter-agent orchestration

Agents coordinate through orchestration protocol v2: workspace-scoped coordinator runs, atomic spawn/readiness/acceptance, durable task ownership, context-aware completion and cancellation, runtime liveness leases, structured results, decision gates, and persistent messaging. A workspace has at most one active coordinator while unrelated workspaces can run concurrently.

💾 Persistent terminal sessions

Close Alera. Reboot. Reopen. Your terminals, their scrollback, their layouts, and the processes you launched are still there. Long-running agent runs survive restarts instead of vanishing with the window.

🎨 Terminal customization

Per-terminal configuration: font, size, theme, behaviour. Built on top of the same engine that powers Ghostty for predictable, high-fidelity rendering.

🗃️ File explorer, search & previews

Browse workspace folders in a tree-based explorer with a git-ignored toggle and inline rename. Search and replace across the workspace with regex and include/exclude patterns. Preview Markdown, PDFs, Mermaid diagrams, and images in dedicated tabs, right next to your terminals.

🔀 Visual source control

Review structured diffs side-by-side or unified, with per-file and aggregated views. Stage, commit, amend, stash, and discard visually, with AI-powered commit message suggestions. A collapsible commit history graph (with a draggable divider) shows HEAD and upstream at a glance, and submodules get lazy read-only status and diff inspection.

✅ Pull requests & checks

Work with pull requests and merge requests per worktree on GitHub, GitHub Enterprise Server, GitLab, and Azure DevOps without leaving Alera: create, edit, comment (with Markdown), toggle draft status, and merge. CI checks are grouped by status with drill-down into check details. Review titles and descriptions can be AI-generated from the branch changes, and the workspace menu opens the repository in your browser in one click. Self-hosted GitHub and GitLab instances are selected explicitly in project settings; Alera uses the hostname from the repository remote with the official gh or glab CLI.

🖥️ Truly native, truly cross-platform

One codebase, three real desktops. Native window chrome, native keyboard shortcuts (⌘ on macOS, Ctrl elsewhere), dark-mode-first UI built on the Alera design system. No Electron, no embedded browser, no 400 MB install.

🔄 Built-in update channel

Stable and release-candidate update channels with a manual download flow today, signed automatic installs as platform trust requirements land.

📱 Mobile companion foundation

A separate Flutter app lives under mobile/ for Android and iOS. Pairing starts from Settings → Mobile Devices in the desktop app or through alera mobile .... The mobile app stores device tokens in platform secure storage and connects directly to the runtime-host mobile WebSocket gateway, so the desktop app does not need to stay open. Its workspace surface mirrors the desktop sidebar with shared grouping, sorting, filtering, tags, collapse state, pins, workspace activity, direct-workspace agent presence, terminal indicators, and managed-workspace actions. Mobile can also browse the host filesystem, manage projects, rename every workspace tab, configure runtime-portable settings and agent hooks, inspect and configure agent quotas, register the host CLI, and install the Alera agent skills without a desktop process. Agent summaries expand locally per paired host, expose runtime-owned details, open the exact terminal tab, and confirm before closing it. Terminal Quick Keys remain local to each phone.

Optional Alera accounts use Google or GitHub sign-in on the desktop. A paired runtime delegates a separate mobile session without asking the phone to repeat provider sign-in. A phone can retain multiple Alera account sessions and subscribe independently to multiple runtimes. After explicit opt-in, the runtime can send Firebase notifications for attention events while the app is closed, with agent-finished and terminal-exit categories available but off by default. Notification payloads can name the project and workspace, but never contain prompts, terminal input or output, source code, or repository contents. The implementation requires production OAuth, cloud, and Firebase configuration before a release can exercise it end to end; Android is the first verification target, while iOS additionally requires Apple signing and APNs configuration.

The standalone runtime can be kept alive on a workstation or VPS with alera runtime start, inspected with alera runtime status, and stopped with alera runtime stop. A non-forced stop refuses to close while sessions or runtime jobs are active. Agent status integrations, automatic agent terminal spawning, and coordinator workers are runtime-owned; use alera runtime agents status, enable, or disable to manage integrations without launching desktop Flutter.

---

What's next

Alera is shipping fast. A non-exhaustive list of what's on the roadmap:

• SSH worktrees: run agents on remote machines as if they were local
• Mobile live transport expansion: add file review and non-terminal tab surfaces to the mobile app
• Code editing with LSP support: full editing with language-server autocomplete and diagnostics
• Git conflict resolution: resolve merge conflicts visually with AI-assisted three-way merge
• Embedded browser & browser use: give agents a real browser to drive
• More forge & tracker integrations: Additional git forges, Linear, and issue-tracker linking per worktree
• Voice, automations, MCP management, skills, and more

See the full roadmap for the complete picture, including difficulty/utility scoring per feature.

---

Install

Linux

Alera installs from a signed package repository so the system libmpv dependency closure resolves through your package manager. The same command installs and updates:

curl -fsSL https://alera.build/install.sh | sh

The script detects apt or dnf, verifies the repository signing key against a fingerprint pinned inside the script, configures the repository, and installs the package. Pass --dry-run to see what it would do, or --repo-only to configure the repository without installing.

Requires x86_64 and Ubuntu 24.04 or newer, Debian 13 or newer, or Fedora. On RHEL, Rocky, and AlmaLinux enable RPM Fusion first, which is where mpv-libs comes from. openSUSE is not supported yet: the published RPM declares Fedora dependency names that openSUSE provides under different names.

To add the repository by hand instead, see the manual setup on the download page. The signing key is published at https://updates.alera.build/linux/alera-archive-keyring.asc with fingerprint 5DE97E7CFE234A1C5869EC54708DA940734CF23A.

macOS

brew tap leynier/tap
brew install --cask alera

Requires Apple Silicon and macOS 14 or newer. The cask clears the quarantine attribute after installing, because the macOS build is not notarized yet.

Or download alera-<version>-macos.tar.gz from GitHub Releases and move Alera.app to /Applications.

Windows

scoop bucket add leynier https://github.com/leynier/scoop-bucket
scoop install leynier/alera

choco install alera

Requires 64-bit Windows. Or download alera-<version>-windows.zip from GitHub Releases and extract it anywhere.

Updating

Alera updates itself only when no package manager owns the installation. Under Homebrew or Scoop, Settings → Updates runs that manager's own upgrade and reopens Alera; under Chocolatey and on Linux it shows the command to run, because those upgrades need elevation or a dependency resolution Alera must not do itself.

Code signing policy

Free code signing provided by SignPath.io, certificate by SignPath Foundation.

SignPath.io runs the signing service and the SignPath Foundation issues the certificate to open source projects at no cost.

Alera is maintained by one person, who fills every role: Leynier Gutiérrez González is the sole committer, reviewer, and approver of signing requests. Data handling is described in the Privacy Policy.

Current status: Linux packages are distributed through a repository whose metadata is signed with the key above. Windows and macOS builds are not signed yet, so Windows SmartScreen reports an unknown publisher and macOS Gatekeeper asks you to allow the app explicitly. Windows signing through SignPath begins once the certificate is issued.

Run from source

Alera is a Flutter desktop app. You'll need a recent Flutter SDK, a working Rust toolchain (rustup), and Zig 0.16.0. The Rust workspace under rust/ provides both the native terminal-host sidecar (alera-cli) and the git layer (alera_native, compiled into the app through flutter_rust_bridge). Zig builds the vendored ghostty_vte terminal engine, which a checkout like this one compiles from its own submodule rather than downloading.

Linux source builds also require system development packages. Install the Ubuntu and Debian prerequisites before running the app.

git clone https://github.com/leynier/alera.git
cd alera
make init-submodules
flutter pub get

# Pick your platform:
flutter run -d macos
flutter run -d windows
flutter run -d linux

By default a local build runs as Alera Dev (dev.leynier.alera.dev) so it can coexist with an installed release without sharing user data. Set ALERA_FLAVOR=release to opt back into the release identifier.

Regenerate the flutter_rust_bridge bindings after changing the Rust API (rust/src/api) with make frb-generate.

---

Performance & architecture

Alera is built around three deliberate engineering choices:

╭──────────────────────────╮    ╭──────────────────────────╮    ╭──────────────────────────╮
│         Flutter          │    │           Rust           │    │      Ghostty VTE         │
│    Native desktop UI,    │ ─> │   PTY + process layer    │ ─> │    Terminal parser &     │
│   shell, design system   │    │    via portable_pty      │    │  renderer (no Electron)  │
╰──────────────────────────╯    ╰──────────────────────────╯    ╰──────────────────────────╯

• Flutter for the desktop shell, design system, and UI: fast startup, consistent look across macOS / Windows / Linux, fully native rendering
• Rust for the PTY and process boundary through portable_pty, so spawning, signalling, and resizing real terminals stays predictable on every OS
• Ghostty's VTE through ghostty_vte_flutter for terminal parsing: the same engine that powers the Ghostty terminal emulator
• Drift / SQLite for local persistence of projects, workspaces, tabs, layouts, settings, and terminal state
• Axum / Postgres for the optional account and push service, kept outside the local runtime-host protocol
• No Electron, no Chromium, no Node runtime in the desktop or mobile apps

For more, see docs/architecture.md.

---

Inspired by great open source projects

Alera stands on the shoulders of brilliant work in the agentic dev and terminal space. Special thanks to:

• Orca: the primary inspiration for worktree-oriented, multi-agent product thinking
• Ghostty: the bar for fast, high-quality terminal experiences
• xterm.js: ecosystem reference for terminal compatibility
• Flutter: the foundation that makes Alera's cross-platform desktop UI possible
• Drift and desktop_updater: used for local persistence and desktop update plumbing

---

Developing

Want to contribute or hack on Alera locally? Start with:

• AGENTS.md: contributor and agent governance rules
• docs/architecture.md: architecture glossary and naming rules
• docs/release-trust.md: release signing, Linux package trust, and update manifest verification
• docs/testing.md: unit, widget, golden, E2E, and coverage workflow
• docs/ui-styleguide.md: design tokens and UI rules

Project layout

• lib/src/app: bootstrap, dependency providers, theme setup
• lib/src/shared: shared infrastructure (process, storage, helpers)
• lib/src/features/projects: project registry and project sidebar UI
• lib/src/features/workbench: workspaces, tabs, split layouts, terminal runtime
• lib/src/features/agent_status: agent lifecycle hooks and activity tracking
• lib/src/features/updater: update archive parsing and desktop updater integration
• lib/src/features/shell: top-level application shell
• lib/src/design_system: shared Alera UI components
• mobile: separate Android and iOS companion app
• rust: native Flutter layer, shared runtime core, and the alera runtime-host CLI
• cloud: containerized Axum account and push service
• edge: Cloudflare Worker that protects and forwards the public API
• infra/production: OpenTofu resources for the production cloud boundary
• landing: static Astro website and account trust pages

Checks

flutter analyze
flutter test --coverage --exclude-tags golden
dart run tool/quality/coverage_report.dart --input coverage/lcov.info --min-lines 100 --worst 25

Use flutter test --tags golden for visual regression tests and flutter test integration_test -d macos for local desktop E2E smoke coverage. See docs/testing.md.

Desktop flavors

Alera builds in two flavors selected by ALERA_FLAVOR:

Flavor	Bundle ID	Display name	Notes
dev	dev.leynier.alera.dev	Alera Dev	Default for local builds. Auto-update disabled.
release	dev.leynier.alera	Alera	Used by CI and public release artifacts.

See lib/src/core/build_flavor.dart for the canonical strings.

---

Releases and updates

Public release cuts are maintainer-managed through GitHub Actions. Release artifacts are signed or packaged for platform trust, and the public update indexes are Ed25519-signed schema v2 manifests with SHA-256 metadata for each artifact. Stable automatic installation stays disabled unless the release build embeds the manifest public key and the platform apply path explicitly allows the artifact type. Stable Linux updates are installed through signed package repositories; release-candidate Linux builds remain manual downloads.

• Stable manifest: https://updates.alera.build/app-archive.json
• Release-candidate manifest: https://updates.alera.build/app-archive-rc.json
• Updater payloads are hosted in Cloudflare R2 under updates/stable/ and updates/rc/
• Stable Linux repositories are hosted in Cloudflare R2 under linux/apt/ and linux/rpm/
• GitHub Releases remain the manual download surface

---

Community & support

• ⭐ Star this repo to follow along. Alera ships often
• 🐛 Found a bug or want a feature? Open an issue
• 🌐 Website: alera.build
• 📜 License: see LICENSE
• 🛡️ Security: see SECURITY.md
• 🤝 Code of conduct: see CODE_OF_CONDUCT.md

---

Reference projects

Reference projects live under reference_projects/ and are non-runtime references for agentic development and orchestration patterns. Alera remains terminal-first and does not depend on any reference project at runtime.