A secure line between Codex agents.

agline connects a local Codex session to a Codex running on a remote machine. The remote agent inspects live logs, processes, host config, and runtime state — then reports back.

Install agline See the flow Open source on GitHub

curl -fsSL https://agline.dev/install.sh | bash

terminal

# server node
$ agline server install
persistent Server Agent installed

# local machine
$ agline connect agp_... --name prod-1
$ agline skill install
# prompt inside local Codex: "/agline check recent errors on prod-1"
$ agline ask --to prod-1 "check recent errors"
checked bounded logs, found 3 timeout events...

What it's for

Remote runtime matters

Use the machine that has the logs, processes, permissions, config, network, and current state.

Codex-to-Codex work

The local side can be a human, script, or Codex. The remote Server Agent uses the Codex already installed and authenticated on that machine.

Not a remote shell

agline is a secure message pipe and orchestration harness, not a command execution API.

How it works

Server Agent Runs on the remote machine, with optional durable server context.

→

Disposable room Each request uses a fresh encrypted 1:1 room through the relay.

→

Client Agent Runs local prompts, targets one or many nodes, and summarizes the results.

Built for Codex

Bundled skill

Install the agline Codex skill so fresh Codex sessions know how to choose targets, phrase compact requests, and summarize evidence.

Your Codex login

agline does not provide a separate AI account. It runs your existing Codex CLI with your local config, OAuth login, model settings, and permissions.

Server context

Keep durable machine facts on the remote Server Agent instead of repeating paths and conventions in every request.

Focused asks

Use agline for bounded remote investigation, multi-node comparison, and concise final answers rather than interactive shell work.

agline skill install

Philosophy

agline is for the moment when the answer is not in your local checkout. It is on the machine that has the live process, the real environment, the current logs, and the same permissions as the runtime.

Instead of tunneling a filesystem or turning the remote host into a shell, agline asks a Server Agent to investigate locally and return the evidence that matters.

The strongest workflow combines both sides: local Codex has your repository, source history, and reasoning context, while remote Server Agents have live logs, health signals, host state, and runtime permissions. Across multiple nodes, that aggregate view becomes the useful part: source-level reasoning plus evidence from the machines actually running the system.

Use agline when you want remote Codex to reason inside the runtime and report back.
Use ask --all when local source context needs evidence from several live servers.
Skip agline when you need interactive shell work or real-time streaming — use SSH instead.

Security model

Encrypted rooms

Disposable rooms are 1:1 and encrypted end to end. The relay forwards opaque payloads.

No command API

agline does not expose a remote execution endpoint. The Server Agent decides what to inspect using its Codex runtime.

Bearer tokens

Persistent tokens are credentials. Keep them within one trust circle and rotate by reinstalling the Server Agent.

Local transcripts

Plaintext history is stored locally for reliable polling. The hosted relay does not store conversation transcripts.

Disposable by default

Persistent Server Agents only rendezvous. Actual work still rotates through fresh disposable rooms.

Best-effort relay

The public relay has no SLA. Production, heavy, or sensitive use should self-host a Cloudflare relay.

Remote Codex boundary

Remote access follows the existing Codex installation, OAuth login, configuration, sandbox, and permissions on the Server Agent machine.

Guide

The common setup is Codex-first: install and authenticate Codex where it will run, install agline, connect the machines once, then use the /agline skill from local Codex for day-to-day remote work.

The agline ask command is still available as the direct CLI primitive, but most users should treat it as advanced once the Codex skill is installed.

Install Codex

Install and authenticate Codex on the remote machine. agline uses that existing Codex CLI, OAuth login, config, model settings, and permissions.

codex auth login

Install agline

Install agline on the local machine and on each remote Server Agent machine.

curl -fsSL https://agline.dev/install.sh | bash

Install a Server Agent

Run this once on the remote machine. The wizard creates a starter server context and uses the Codex already authenticated there.

agline server install

Connect locally

Use the persistent token printed by the remote install.

agline connect <agp-token> --name prod-1

Use the Codex skill

Install the skill on your local Codex machine, then type `/agline ...` as a prompt inside Codex. The skill chooses the target and shapes compact remote requests.

agline skill install Codex prompt: "/agline check recent errors on prod-1" Codex prompt: "/agline compare recent health signals across all targets"

Advanced CLI asks

Use direct CLI asks for scripts, automation, or when you are not inside Codex.

agline ask --to prod-1 "check recent errors" agline ask --all "compare recent health signals"