Claude Code / Codex / Copilot / Gemini

One CLI for every coding agent

Use one predictable command line across Claude Code, Codex CLI, GitHub Copilot CLI, and Gemini CLI. Start, resume, find, name, fork, and hand off sessions without memorizing four incompatible interfaces - while keeping each agent CLI's native arguments one command away.

The productivity gain compounds: one muscle memory runs every agent, sessions stay findable and resumable however they were started, and switching vendors becomes a flag on the next session instead of a migration - your workflow is multi-vendor by default, so no single agent CLI can hold it hostage.

Install acli See the commands

Install acli

The installer detects your platform, downloads the precompiled binary acli 1.116.1, verifies its published SHA-256 digest, and installs it atomically in ~/.local/bin. 

curl -qfsSL https://www.lifub.com/acli/install.sh | bash

No package manager, administrator access, Rust toolchain, Cargo installation, Apple Developer ID, or access to the private source repository is required. You can inspect the installer before running it. After installation, acli update verifies and installs future releases atomically; rerunning this command remains a manual recovery path. If your installed version predates acli update, rerun the installer once to join the self-updating release line.

From install to first session

  1. Install and authenticate at least one supported agent CLI.
  2. Run acli doctor to check installations and compatibility.
  3. Start with acli start codex, or run acli resume to choose an existing session.
$ acli doctor
$ acli start codex
$ acli resume

The interface stays. The agent CLI can change.

acli translates a small, stable vocabulary into each installed agent CLI. Use the same agent names, session references, permission mode, model option, and reasoning-effort option; acli rejects combinations an agent CLI cannot support instead of quietly changing their meaning.

Start

Open a fresh session

acli start claude

Swap claude for codex, copilot, or gemini. The command shape stays the same.

Continue

Find work by name

acli resume checkout --agent codex

Use a readable display name, narrow the picker with --agent, or pass a qualified UUID directly for the fastest exact-ID path.

Switch

Hand work to another agent CLI

acli handoff checkout --from claude --to codex

Create a new target session with the useful visible conversation carried forward.

Balanced from the first prompt

Fresh starts and handoff targets use medium effort where supported: rolling Claude opus, the best visible medium-capable Codex model (or its configured model if the catalog is unavailable), or Copilot auto. Gemini keeps its native model default.

Continue at the same quality

Resume restores recorded permissions, model, and effort wherever the agent CLI persists them. Missing values receive independent unrestricted and balanced fallbacks. A native fork inherits source quality. Explicit overrides always win.

Full access for new sessions

New starts, forks, and handoff targets default to --permissions unrestricted. Use --permissions inherit when the agent CLI's configured permission policy should remain in control. Permissions never select a model, effort, or search policy.

acli MCP is ready by default

Managed start, resume, fork, and handoff launches make one aggregate acli MCP server available to the selected agent CLI. acli preflights the service and creates a persistent user-scope registration only when it is missing. Existing provider restrictions and deliberately disabled registrations remain authoritative.

One reviewed public catalog

The server exposes Lifub's hosted web, DNS, request, Site Audit, and WHOIS tools plus public resources and prompts. Private CI and local workspace read, write, and bash tools are not part of the public binary, even when called by a guessed name.

Per-launch opt-out

Add --no-acli-mcp before the native -- boundary to disable acli MCP for one managed launch without removing unrelated MCP servers. The choice is not saved, so a later launch returns to the default. acli exec remains exact and unmanaged.

Capability is not approval

Tool discovery never grants permission to call a tool: the selected agent CLI's approval and sandbox policy stays in control. Calls send their bounded inputs to https://api.lifub.com/mcp, where request-size, proof-of-work, rate, and quota limits apply.

Browser authority: Vynx browser tools appear only for a locally configured personal, corporate, or Safari profile. A call can operate that live browser session with the authority already available there. acli ignores model-supplied session IDs and removes configured identifiers from forwarded data and errors.
Same-user boundary: the agent CLI and acli mcp serve run as the same operating-system user. This prevents accidental catalog exposure but is not credential isolation from a hostile process running as that user.

Recognize the session before you open it

acli resume opens one searchable catalog across all four agent CLIs. The picker shows each session's full qualified ID, display name, workspace, age, and last visible assistant output (or the last user message when no answer exists), so repeated names no longer force UUID guesswork. 

Choose a saved AI session
Search: checkout

> [claude] checkout                                             8m
  [codex] checkout                                      RUNNING
  [copilot] checkout                                          2h

claude:1803904f-a859-49a9-91fe-85613902d39b - ~/src/shop
Last assistant output
  The checkout tests pass. The remaining task is to update the release notes.

type to filter | arrow keys navigate | enter continue | esc cancel

Ambiguity is a choice, never a guess

Exact duplicate names and useful close matches open the same preview picker in an interactive terminal. Non-interactive commands fail with qualified candidates instead of consuming input or selecting a session silently.

See active work

A Codex session owned by another terminal is marked RUNNING. acli refuses a second normalized resume before two processes can write to the same session.

Readable in every terminal

ANSI color separates selection, status, metadata, and preview roles. NO_COLOR and the standard CLICOLOR controls are respected.

Continue the work with another agent CLI

A handoff creates a new target session from a portable, local transcript. This is useful when a task outgrows one model, an agent CLI is unavailable, or you want a fresh perspective without writing a handoff from scratch. 

$ acli handoff checkout --from claude --to codex
$ acli handoff release-notes --from copilot --to gemini --unverified

Visible text crosses as written

acli carries visible user and assistant text without redacting it, so a secret or machine-local path pasted into the visible conversation crosses too. Review sensitive conversations before handing them off. The portable JSON excludes hidden instructions, tool calls and output, attachments, agent-owned session IDs, workspace metadata, timestamps, and skill files. The receiving agent is told to rerun any result it needs but cannot see.

Private, bounded, and cleaned up

The handoff uses a size-bounded private artifact on your machine. A small launch envelope still identifies the source agent, carries a sanitized display name, and gives the target the absolute artifact path. acli removes the artifact immediately after every handled target exit; a later handoff removes crash leftovers after one day.

Codex reads without a new writable root

Codex receives the artifact's absolute path in its prompt; acli does not add the artifact directory as a writable --add-dir. Paths you explicitly pass with --add-dir remain additional workspace roots.

Resources resolve locally

acli never copies referenced skill or resource files. The target resolves each named resource from its own installed environment instead of assuming a source-machine absolute path exists, and reports anything missing without inventing a replacement.

Mark stale context explicitly

Add --unverified when the source may be outdated. The receiving agent is instructed to re-establish claims, decisions, file contents, and results before acting on them.

Commands at a glance

The public CLI uses action-first commands. Run any command with --help for its exact agent, model, effort, JSON, and agent CLI argument options.

acli start <agent> [-p <prompt>] [--no-acli-mcp] [--permissions <mode>] [--model <model>] [--effort <level>] [--add-dir <dir>]...
Start a fresh Claude, Codex, Copilot, or Gemini session with balanced quality defaults.
acli resume [session] [--agent <agent>] [-p <prompt>] [--no-acli-mcp] [--permissions <mode>] [--model <model>] [--effort <level>] [--add-dir <dir>]...
Resume through the universal picker or narrow a display name to one agent CLI. A qualified positional UUID, such as codex:0192d9f0-0000-7000-8000-000000000000, skips discovery.
acli fork [session] [--agent <claude|codex>] [-p <prompt>] [--no-acli-mcp] [--permissions <mode>] [--model <model>] [--effort <level>] [--add-dir <dir>]...
Branch through the native fork operation, preserving source quality unless --model or --effort overrides it.
acli handoff [source-session] [--from <agent>] --to <agent> [--unverified] [--no-acli-mcp] [--permissions <mode>] [--model <model>] [--effort <level>] [--add-dir <dir>]...
Create a new session in another agent CLI from the source's portable visible transcript.
acli exec <agent> -- <native args>
Run the agent CLI with byte-for-byte arguments and no acli policy injection.
acli session list [--agent <agent>] [--json]
Inspect the cross-agent catalog, coverage diagnostics, names, workspaces, and active sessions. JSON uses a stable sessions array and session_count coverage field.
acli session capabilities [<agent>]
See which list, resume, fork, rename, archive, restore, and delete operations each agent CLI exposes safely.
acli session rename <agent>:<id-or-name> <display-name> [--json]
Apply a memorable display name through a public agent CLI rename interface or a safe acli-owned alias.
acli session archive|restore <agent>:<id>
Use supported agent session lifecycle operations with an exact qualified ID.
acli session delete <agent>:<id> --yes
Permanently delete a session only when its agent CLI exposes a stable-ID operation.
acli context status|diff|sync
Inspect shared instructions and already-installed local resources. Sync creates missing links only to canonical resources already installed on this machine, never bundles or copies skills, and reports a missing source without inventing one.
acli mcp status|diff [--agent <agent>]
Inspect the persistent acli MCP registration across one installed agent CLI or every available one.
acli mcp sync|remove [--agent <agent>] --yes
Create or remove only exact acli-owned registrations. Sync verifies acli before retiring exact-owned lifub or loxal aliases; remove works offline.
acli mcp serve
Run the aggregate MCP server used by the persistent agent CLI registrations.
acli repo commit [--stage-all] [--push]
Generate an AI commit message for staged changes. Add --stage-all to include the whole working tree and --push to push the new commit without pulling, rebasing, or resolving conflicts.
acli doctor
Check installed agent CLI versions, required command contracts, available updates, and session capabilities.
acli update
Show the installed and latest acli versions, verify the immutable release manifest, size, SHA-256 digest, and staged binary version, then replace acli atomically.

Unified does not mean pretending agent CLIs are identical

Agent CLIs expose different session APIs and accept different model and effort values. acli normalizes what can be normalized, reports the capability boundary supported by this acli version, and fails clearly when a requested operation is unsupported. It never invents a destructive workaround against an agent CLI's private store.

Check before automating: run acli session capabilities <agent>. Every launch command accepts agent CLI options after --; acli exec is the exact, no-injection form.

New sessions start with full access

start, fork, and a new handoff target default to --permissions unrestricted, mapping to each agent CLI's approval, sandbox, and trust bypass controls. Use --permissions inherit to add no acli permission override. Conflicting native permission flags fail instead of silently weakening the effective request. Permissions never select a model, effort, or search policy. Repeat --add-dir for explicit extra workspace roots. Use acli's default only in a workspace and account you intentionally trust with unattended access; managed agent or environment policy can still take precedence.

Fresh-session quality: Claude uses its rolling opus alias at medium effort; Codex selects the highest-priority visible model that supports medium effort (currently GPT-5.6 Sol), falling back to the configured Codex model if its catalog is temporarily unavailable; Copilot uses auto at medium; Gemini keeps its native model and exposes no effort control. Claude accepts effort from low through max, Codex from none through ultra, and Copilot from none through max, including minimal.
Continuity first: Resume reapplies each recorded permission, model, and effort value when it is readable; explicit --permissions, --model, and --effort values always win. Missing components fall back independently to unrestricted permissions and fresh-session quality. Claude, Codex, and Copilot persist permission state; Gemini does not, so Gemini resumes use the unrestricted fallback. Gemini has no effort setting. Older Copilot sessions created with auto may expose only the last actual model. Fork delegates quality inheritance to the agent CLI unless you override it.

Platforms and requirements

macOS

Apple Silicon and Intel are supported on macOS 11 or newer.

Linux

x86_64 glibc Linux is supported and tested on Ubuntu 22.04 and 26.04. Linux ARM64 and Alpine/musl are not available yet.

Agent CLIs are separate prerequisites. acli does not bundle Claude Code, Codex CLI, GitHub Copilot CLI, or Gemini CLI. Install and authenticate only the agent CLIs you intend to use. Those agent CLIs remain responsible for their own accounts and network traffic.

A fail-closed download path

For every public version, the release pipeline:

  1. builds with private features disabled under an otherwise empty, allowlisted environment;
  2. pattern-scans the resulting binary strings for known credential prefixes, private-key markers, private path patterns, and internal identifiers - a defense against accidental disclosure, not an absolute guarantee that a binary contains no sensitive data;
  3. publishes a versioned manifest containing the SHA-256 digest for every supported platform artifact;
  4. has the installer download to a temporary location, verify the expected SHA-256 digest, and fail closed on any mismatch;
  5. completes dependency and licensing review and tests each supported platform artifact; and
  6. installs atomically into a user-owned directory, without sudo, only after every check succeeds.

Piping a remote script into a shell carries risk. Inspect the installer before executing it and verify that the HTTPS hostname is exactly www.lifub.com before running the command.

Questions before you install

Does acli replace or bundle my agent CLIs?

No. It is a stable interface over the agent tools already installed and authenticated on your machine.

How do I update acli?

Run acli update. It shows the current and latest versions, downloads only from Lifub's fixed HTTPS release endpoint, verifies the immutable manifest, byte size, SHA-256 digest, and staged binary version, then atomically replaces the existing binary. Any failure leaves the old version installed. If your version predates this command, rerun the installer once; later releases update through acli itself.

How do I uninstall it?

Run acli mcp remove --yes first if you want exact acli-owned current and legacy MCP entries removed from every installed agent CLI, then remove ~/.local/bin/acli. Removing only the binary leaves the persistent provider registrations in place for direct provider launches, pointing at the now-missing executable. Agent-owned sessions remain untouched. acli state and display aliases remain in ~/.local/state/acli unless you choose to remove them separately.

Can I use acli in scripts?

Yes. Use a qualified positional UUID such as acli resume codex:0192d9f0-0000-7000-8000-000000000000 for deterministic selection and acli session list --json for machine-readable discovery. Its stable schema names records sessions and reports coverage with session_count. Non-interactive commands never open a picker or guess between ambiguous names.

What happens when an agent CLI changes?

acli doctor checks the installed versions and command options on which the unified interface depends. It reports an exact update hint when an installed agent CLI is behind.

Keep the workflow. Choose the agent CLI.

Install acli, run acli doctor, and open your first unified session.

Install acli Browse every command