╔───────────────────────────────────────────╗
│                                           │
│           __       ___   .___________.    │
│          |  |     /   \  |           |    │
│          |  |    /  ^  \ `---|  |----`    │
│    .--.  |  |   /  /_\  \    |  |         │
│    |  `--'  |  /  _____  \   |  |         │
│     \______/  /__/     \__\  |__|         │
│                                           │
│         ◇ Supervise the Swarm ◇           │
│                                           │
╚───────────────────────────────────────────╝

JAT — Autonomous Agents, Supervised or Not

Agents ship, suggest, repeat. You supervise — or they run on their own.

JAT is the complete, self-contained environment for agentic development. Task management, agent orchestration, code editor, git integration, terminal access—all unified in a single IDE. Connect RSS, Slack, Telegram, Gmail — events create tasks and spawn agents automatically. No plugins to install, no services to configure, no pieces to assemble. Supervise the swarm hands-on, or let it run autonomously while you sleep.

The JAT IDE: agent sessions, task management, and code editor unified

The Paradigm Shift

Traditional IDE:       You write code, tools assist
Copilot IDE:           You write code, AI suggests completions
Agentic IDE:           Agents write code, you supervise and approve
Autonomous Platform:   Events trigger agents, work ships while you sleep

JAT supports all four. Manage 20+ agents hands-on, or connect external sources and let agents spawn themselves.

Quick Start

# Install (one command)
curl -sSL https://raw.githubusercontent.com/joewinke/jat/master/tools/scripts/bootstrap.sh | bash

# Restart shell
source ~/.bashrc

# Launch
jat

Open http://localhost:3333 → Add a project → Create a task → Spawn an agent → Supervise

Alternative (developers):

git clone https://github.com/joewinke/jat.git ~/code/jat
cd ~/code/jat && ./install.sh

VPS / Remote Server (Arch Linux or Ubuntu):

curl -sSL https://raw.githubusercontent.com/joewinke/jat/master/tools/scripts/vps-setup.sh | bash

Sets up everything — swap, Node.js, Tailscale, Claude Code, firewall, JAT, and a systemd service that auto-starts on boot and restarts on crash. Access via http://<tailscale-ip>:3333.

Complete IDE Features

Keyboard Shortcuts

Every route supports vim-style j/k navigation. Press ? on any page for the full shortcut overlay.

Full per-route reference: ide/docs/keyboard-navigation.md.

Voice Commands

Hold Ctrl+Space and talk. JAT runs a two-tier dispatcher: fixed phrases fire keyboard shortcuts (sub-second, no LLM); natural-language utterances are routed through an LLM that extracts parameters and chains actions in one shot.

"Create a bug for the login crash and spawn an agent"
   → opens new-task drawer (title="login crash", type=bug)
   → spawns an agent on the new task

"Close the auth task"                              → confirms, then closes
"Set the auth task to P1 and assign it to Mike"    → updates two fields in one call
"Spawn four agents on the triage epic"             → opens swarm dialog pre-filled
"Kill the EarlyShore session"                      → confirms, then kills

Open the in-app Voice Vocab Sheet (mic button or ? overlay) to see every command available on the page you're on, with example utterances. Full guide: ide/docs/voice-commands.md.

Code Editor (/files)

Full Monaco editor (VS Code's engine):

┌─────────────────────────────────────────────────────────────┐
│  📁 Files  │  🔀 Git                                        │
├─────────────────────────────────────────────────────────────┤
│  ▼ src/    │  ┌─────┬─────┬─────┐                           │
│    lib/    │  │ a.ts│ b.ts│ c.ts│  ← Drag-drop tabs         │
│    routes/ │  └─────┴─────┴─────┘                           │
│  ▼ tests/  │  ┌──────────────────────────────────────────┐  │
│            │  │  Monaco Editor                           │  │
│            │  │  • 25+ languages                         │  │
│            │  │  • Syntax highlighting                   │  │
│            │  │  • Multi-cursor editing                  │  │
│            │  └──────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

• Lazy-loading file tree with right-click context menu
• Multi-file tabs with persistent order
• Keyboard navigation (F2 rename, Delete remove)
• File type icons

Git Source Control (/files → Git tab)

Full git integration:

┌─────────────────────────────────────────────────────────────┐
  ⎇ master  ↑2 ↓0                                   [⟳ Fetch] │
├─────────────────────────────────────────────────────────────┤
│  ▼ STAGED CHANGES (3)                               [− All] │
│    M  src/lib/api.ts                                        │
│    A  src/lib/auth.ts                                       │
├─────────────────────────────────────────────────────────────┤
│  [ Commit message...                          ] [✓ Commit]  │
├─────────────────────────────────────────────────────────────┤
│  ▼ CHANGES (2)                                      [+ All] │
│    M  src/routes/+page.svel te                    [+] [↻]   │
├─────────────────────────────────────────────────────────────┤
│  [↑ Push]  [↓ Pull]                                         │
├─────────────────────────────────────────────────────────────┤
│  ▼ TIMELINE                                                 │
│    ● abc123  2h ago   Add authentication                    │
│    ○ def456  1d ago   Fix login bug                         │
└─────────────────────────────────────────────────────────────┘

• Stage/unstage individual files or all
• Commit with Ctrl+Enter
• Push/Pull with ahead/behind indicators
• Branch switcher with search
• Diff preview drawer (click any file)
• Commit timeline with details

Two Hierarchical Namespaces: /tasks and /epics

JAT's IDE is organized around two primary hierarchical surfaces, one at each level of the work hierarchy:

• /tasks (task-level namespace): the task queue, board, and triage. Individual tasks, their lifecycle, agent sessions, and questions.
• /epics (epic-level namespace): the cockpit where you see all epics and pilot one. The epic-level twin of /tasks. An epic is the unit of work, its dependency graph IS the epic, and "piloting" is the mode you enter on an epic to drive its graph (running agents, live/history, the Overseer autonomy engine).

Agent Sessions (/tasks)

Live terminal output for all running agents:

• Real-time streaming output
• Smart question UI (agent questions → clickable buttons)
• State badges: Working, Needs Input, Review, Completed
• Send input directly to agents
• Token usage and cost tracking

Task Management (/tasks)

JAT Tasks-powered issue tracking:

• Create tasks with priorities (P0-P4)
• Epic workflows with subtask spawning
• Dependency visualization
• Bulk actions (select multiple, add to epic)

Epic Cockpit (/epics)

The epic-level namespace. See every epic and pilot one end to end:

• All epics across projects, with progress and velocity
• Pilot an epic: its dependency graph, ready/running/blocked tasks
• Live agent sessions and run history for the active epic
• The Overseer autonomy engine (L0-L3 autonomy levels) drives the graph: launch, approve, redirect, escalate

Source Control (/source)

Full commit history and repository management:

• Browse all commits with details
• Multi-select commits for cherry-pick or revert
• Search commits by message or author
• Diff viewer for any commit

The Agentic Flywheel

┌──────────────────────────────────────────────────────────────┐
│                                                              │
│   1. PLAN WITH AI        Describe your feature, get PRD      │
│         ↓                                                    │
│   2. /JAT:TASKTREE           Convert PRD → structured tasks  │
│         ↓                                                    │
│   3. EPIC SWARM          Spawn agents on subtasks            │
│         ↓                                                    │
│   4. PARALLEL WORK       Watch agents code simultaneously    │
│         ↓                                                    │
│   5. SMART QUESTIONS     "OAuth or JWT?" → click button      │
│         ↓                                                    │
│   6. REVIEW IN /tasks    See diffs, approve changes          │
│      OR PILOT IN /epics  Let Overseer drive the epic graph   │
│         ↓                                                    │
│   7. COMMIT & PUSH       Stage, message, push                │
│         ↓                                                    │
│   8. AUTO-PROCEED        Low-priority tasks complete auto    │
│         ↓                                                    │
│   9. SUGGESTED TASKS     Agent proposes next work            │
│         ↓                                                    │
│        ╰──────────────── Auto-accept → back to 3 ───────────╯│
│                                                              │
│            ∞  Perpetual motion. Ship continuously.  ∞        │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Integrations & Autonomous Triggers

JAT connects to external sources. When events arrive, tasks are created and agents spawn — no human in the loop required.

Built-in Integrations

Trigger Modes

Example: Telegram to Shipped Code

1. You message your Telegram bot: "Add dark mode to the settings page"
2. JAT ingest daemon receives the message
3. Task created: "Add dark mode to the settings page" (P1, immediate trigger)
4. Agent spawns automatically, picks up the task
5. Agent writes code, commits, opens PR
6. You wake up to a completed PR

Task Scheduler

The built-in scheduler daemon (jat scheduler start) handles cron and one-shot triggers. It polls task databases, spawns agents for due tasks, and manages recurring schedules automatically. See scheduler docs.

Custom Integrations

Build your own adapter with the plugin system. See PLUGINS.md for the adapter interface.

Routes

JAT's two primary hierarchical namespaces are /tasks (task-level) and /epics (epic-level).

What Makes JAT Different

Full Monaco editor and git integration included—but the magic is in agent orchestration.

JAT vs Other AI Coding Tools

JAT isn't trying to replace your editor — it's the control tower for your agent swarm, whether you're at the controls or asleep.

Architecture

~/code/jat/
├── ide/          # SvelteKit app (the IDE)
│   └── src/
│       ├── routes/     # /tasks, /epics, /files, /source, /integrations, /servers, /config
│       └── lib/
│           ├── components/files/   # FileTree, GitPanel, Editor
│           ├── components/work/    # SessionCard, WorkPanel
│           ├── components/source/  # CommitHistory, DiffViewer
│           ├── components/ingest/  # Integration management UI
│           └── stores/             # State management
├── tools/              # 50+ CLI tools
│   ├── core/           # Database, monitoring
│   ├── mail/           # Agent coordination (am-*)
│   ├── browser/        # Browser automation
│   ├── ingest/         # Feed ingest daemon (RSS, Slack, Telegram, Gmail)
│   ├── scheduler/      # Task scheduling daemon (cron + one-shot)
│   └── signal/         # State sync
├── commands/           # /jat:start, /jat:complete, /jat:tasktree
└── shared/             # Agent documentation

Requirements

• Node.js 20+
• tmux (agent sessions)
• Claude Code or similar AI assistant
• sqlite3, jq (auto-installed)

Authentication

No API keys required. JAT uses your existing AI assistant subscriptions.

Most coding agents authenticate via their own subscriptions — no separate API keys needed:

JAT's built-in AI features (task suggestions, avatars) use an auto-fallback system:

1. Anthropic API key — if configured (optional)
2. Claude CLI — falls back to your Claude subscription via claude -p

If you have Claude Code installed and authenticated, AI features work out of the box with zero configuration.

Configuration

~/.config/jat/projects.json:

{
  "projects": {
    "myapp": {
      "path": "~/code/myapp",
      "port": 3000,
      "tunnels": [
        { "local_port": 5433, "ssh_host": "user@myserver", "remote_host": "10.0.1.7", "remote_port": 5432 }
      ]
    }
  },
  "defaults": {
    "max_sessions": 12,
    "model": "opus",
    "scheduler_autostart": true,
    "timezone": "America/New_York"
  }
}

tunnels — SSH port-forward tunnels to establish automatically before starting the dev server. Each entry maps a local_port on your machine to remote_host:remote_port via an SSH BatchMode connection to ssh_host. Ports already listening are skipped. Useful when the dev server needs to reach a remote database or object store over an SSH bastion.

Optional: API keys and project secrets can be managed at /config → API Keys tab, or stored in ~/.config/jat/credentials.json:

{
  "apiKeys": {
    "anthropic": { "key": "sk-ant-..." }
  },
  "customApiKeys": {
    "stripe": { "value": "sk_live_...", "envVar": "STRIPE_API_KEY" }
  },
  "projectSecrets": {
    "myapp": { "supabase_anon_key": { "value": "..." } }
  }
}

Access secrets in scripts:

jat-secret stripe              # Get value
eval $(jat-secret --export)    # Load all as env vars

IDE settings at /config:

• API keys and custom secrets (optional)
• Per-project credentials (Supabase, databases)
• Agent routing rules
• Automation rules
• Keyboard shortcuts

Documentation

FAQ

Which AI assistants work? Any terminal-based AI: Claude Code, Aider, Cline, Codex, etc.

How many agents can I run? Tested with 20+. Limited by your machine and API limits, not JAT.

Can I use existing projects? Yes. Run jt init in any git repo to initialize task tracking, then add the project via /config → Projects tab, or use the "Add Project" button on the Tasks page.

Can JAT act on Slack/Telegram messages? Yes. The ingest daemon connects to Telegram bots, Slack channels, RSS feeds, and Gmail. Incoming events create tasks and spawn agents automatically — immediately, on a delay, at a scheduled time, or on a cron. See Integrations.

Can I schedule recurring tasks? Yes. Set a cron expression on any task and the scheduler daemon will spawn agents automatically. See scheduler docs.

Is there a hosted version? No hosted service. JAT runs on your own machine or your own VPS — code never leaves infrastructure you control.

Community

• Discord — Join the JAT community for help, discussion, and sharing what you've built
• Issues — Report bugs or request features
• Discussions — GitHub Discussions for questions and ideas

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Quick start for contributors:

git clone https://github.com/joewinke/jat.git ~/code/jat
cd ~/code/jat/ide
npm install && npm run dev

Open a PR against master. All contributions are licensed under MIT.

Credits

• Developer — Creator Github
• Agent Registry — Original Agent Comms inspiration (Dicklesworthstone/mcp_agent_mail)
• Beads — Original task management inspiration (steveyegge/beads)
• Mario Zechner — Think different about Agents (What if you don't need MCP?)
• Andrej Karpathy - Naming the Problem (Some Powerful Alien Tool)
• DHH - Developer-centric OS (Omarchy)
• Tmux - Terminal Multiplexer by (Nicholas Marriott)
• Monaco — Code editor engine (Microsoft)
• SvelteKit — IDE framework (Rich Harris)
• Tailwind CSS — Utility-first CSS (Adam Wathan)
• DaisyUI — Component library (Pouya Saadeghi)
• Git — Version control (Linus Torvalds)
• simple-git — Node.js Git wrapper (Steve King)
• D3.js — Data visualization (Mike Bostock)
• Vite — Build tool (Evan You)
• SQLite — Embedded database (D. Richard Hipp)
• TypeScript — Type safety (Anders Hejlsberg)
• Claude — Wrote a lot of the code (Anthropic)

License

MIT - This is my gift to all the great's who haved gifted so much to all of us. If you use this software, use it to make something you give back to open-source.

Star History

JAT: Supervise the swarm — or let it run autonomously.

Install | Docs | Discord | Issues