Use agents for real work. Stay in control.
Getting agents to do things isn't the hard part anymore. Keeping track of everything they do โ
without losing context, missing changes, or creating messes you can't untangle โ is.
AGX is how I use agents seriously. Works with Claude, Codex, Gemini, and Ollama.
```bash
npm install -g @mndrk/agx && agx init
```
AGX is a local workspace for running coding agents across your tickets, repos, and PRs โ you stay the author.
Website โข
Blog โข
Install โข
Features โข
How It Works โข
CLI
---
## Why I built this
Hi, I'm Mendrika.
I built AGX because I kept wanting to use agents for more and more real work. Feature builds. Bug fixes. Research. Follow-up tasks. The problem was never getting them to do things. The problem was keeping track of everything without getting lost.
That started to feel like the real bottleneck. The better the agents got, the more parallel work I wanted to run. And the more parallel work I ran, the easier it was to lose context, miss changes, and create messes I couldn't reliably untangle.
AGX is my attempt to solve that. It's an exploration of what it would take to use agents seriously, while still staying in control.
Ships as a CLI, a local web dashboard, and a macOS desktop app โ all from one repo.
### What staying in control looks like
| | Ad-hoc agent usage | AGX |
|---|---|---|
| **Tickets** | Live in Jira/Linear, separate from the agent | Ticket, code, PR, and review in one window |
| **Parallel work** | Tabs, scrollback, mental bookkeeping | Every ticket has a home; see what's moving at a glance |
| **Picking up where you left off** | Re-explain everything from scratch | Instant โ the ticket remembers |
| **Human gates** | Whatever you remember to check | Built-in approve/reject before anything irreversible |
| **PR review** | Read the diff cold, guess at intent | First pass from a reviewer agent โ you review what actually needs your judgment |
| **Provider lock-in** | One provider per session | Switch Claude โ Codex โ Gemini โ Ollama freely |
| **Observability** | Terminal scrollback | Dashboard, live presence, activity log |
---
## Quickstart (2 minutes)
```bash
npm install -g @mndrk/agx
cd my-project
agx init # Picks up your API keys automatically
agx board start # Open the ticket โ agent โ PR board
```
## Get AGX
### npm (recommended)
```bash
npm install -g @mndrk/agx
cd my-project
agx init # First-time setup โ picks up your API keys
agx board start # Open the local dashboard
```
### Desktop App (macOS)
Download from [Releases](https://github.com/ramarlina/agx/releases). Bundles the UI, CLI, and Node runtime โ install and go.
Build from source
```bash
git clone https://github.com/ramarlina/agx.git
cd agx && npm install
npm run local:dev # Run the dashboard in dev mode
```
---
## What You Get
- **Ticket โ agent โ PR loop** โ Point an agent at a Jira or Linear ticket, review the draft, ship the PR. Your tickets, repos, and PRs live in one window.
- **Human-in-the-loop at every gate** โ Agents pause for your explicit approve/reject before anything irreversible. PR review starts with a first-pass from a reviewer agent so you spend judgment where it matters.
- **Chat with any provider** โ Claude, Codex, Gemini, Ollama. Switch freely mid-thread.
- **A home for every ticket** โ Objectives, scheduled jobs, chat threads, and terminal sessions all live under their project. Nothing is free-floating.
- **Agent teams** โ Group agents by role (engineering, research, ops). Work routes automatically by tag.
- **Survives restarts** โ Close your laptop, pick it up tomorrow. State is checkpointed, not rebuilt from conversation history.
- **Live presence** โ See which agents are active on which projects and tickets in real time.
- **Fully local** โ Runs on your machine. Your code never leaves. Full activity log, signed actions, destructive-command safeguards.
---
## How It Works
AGX runs the **ticket โ implementation โ PR โ review** loop. Tickets from Jira or Linear come in, agents draft the work, humans approve at every gate, and PRs go out.
Under the hood, work is checkpointed at every step โ so closing your laptop, restarting the machine, or coming back tomorrow all pick up exactly where you left off. Resuming is constant-cost: a thread that's been running for a week resumes as fast as one that started a minute ago.
### Architecture
- **State layer** โ SQLite (WAL mode), durable checkpoints
- **CLI + daemon** โ Provider tool calls, filesystem edits, worktree isolation
- **Decision layer** โ Human gate transitions, review flow
Everything runs locally. Your code never leaves your machine.
---
## CLI Quick Reference
```bash
agx init # First-time setup
agx board start # Open the ticket โ agent โ PR board
agx claude -p "..." # Chat with Claude (or codex / gemini / ollama)
```
| Provider | Alias | Command |
|----------|-------|---------|
| Claude | `c` | `agx claude -p "..."` |
| Codex | `x` | `agx codex -p "..."` |
| Gemini | `g` | `agx gemini -p "..."` |
| Ollama | `o` | `agx ollama -p "..."` |
Full CLI reference
### Projects & Repos
```bash
agx project list # List projects
agx repo add . --project my-project # Analyze current repo and attach it
agx repo add ../service --project my-project --name API
agx workspace list --project my-project # Show workspace map entries by category
agx workspace add repos backend /code/api --project my-project
agx workspace remove repos backend --project my-project
```
### Environment Variables
```bash
agx vars set API_URL https://example.com # Set a variable
agx vars get API_URL # Get a variable
agx vars list # List all variables
```
### Setup
```bash
agx init # First-time setup wizard
agx config # Reconfigure providers, models, backend URL
```
---
## Prerequisites
- **Node.js** >= 22.16.0 (CLI install only; desktop app bundles its own runtime)
- **At least one AI provider CLI:**
[Claude Code](https://claude.com/claude-code) ยท
[Codex CLI](https://www.npmjs.com/package/@openai/codex) ยท
[Gemini CLI](https://ai.google.dev/gemini-api/docs/cli) ยท
[Ollama](https://ollama.ai/)
No external database required. AGX uses SQLite locally.
---
Development
This repo is an npm workspace. CLI, dashboard, and desktop app all live here โ clone once, run everything.
```text
agx/
apps/
local/ # Next.js dashboard (project home, chat, terminal, teams, objectives, tasks)
desktop/ # Electron macOS app (bundles dashboard, CLI, and Node runtime)
lib/ # CLI and runtime source
commands/ # CLI command implementations
cloud-runtime/ # Packaged standalone dashboard bundled into the npm artifact
```
### Run the dashboard
```bash
npm install
npm run local:dev # Start the dashboard at localhost
```
### Build the dashboard
```bash
npm run local:build # Production build
npm run board:bundle # Package standalone runtime for the CLI
```
### Desktop app
```bash
cd apps/desktop
npm run dev # Launch Electron in dev mode
npm run build:mac # Build the macOS .app + .dmg
```
### Tech stack
* **Dashboard/Chat:** Next.js, Tailwind CSS
* **Desktop:** Electron, electron-builder
* **Database:** SQLite (WAL mode)
* **Runtime:** Node.js (TypeScript / `tsx`)
* **Streaming:** EventSource (CLI โ board)
Contributing
Contributions welcome.
* **Ideas & questions:** GitHub Discussions
* **Bugs & features:** GitHub Issues
* **PRs:** Fork `main`, add tests, submit
Telemetry
**Telemetry is enabled by default.**
AGX collects anonymous usage data to improve the tool. Here's exactly what we collect:
| Data | Example |
|------|---------|
| OS & architecture | `darwin`, `arm64` |
| Node.js version | `v22.16.0` |
| AGX version | `1.4.55` |
| Commands run | `new`, `daemon start` |
| Provider used | `claude`, `codex`, `gemini`, `ollama` |
| Task outcomes | `completed`, `failed` |
| Timing | `duration_ms: 12345` |
**We do NOT collect:** prompts, code, API keys, file paths, or any PII.
### Disable telemetry
```bash
agx telemetry off
# or: export AGX_TELEMETRY=0
# or: ~/.agx/config.json โ { "telemetry": { "enabled": false } }
```
---
## License
MIT
---
Direct the work. Let agents handle the busywork. Stay the author.
โญ Star this repo if AGX saves you time ยท Report a bug ยท runagx.com