A local-first Web UI for managing multiple agentic coding sessions across multiple GitHub repos. Each session runs in its own Docker sandbox, works on its own Git branch, and streams Claude Code Agent SDK messages to the UI via WebSockets.

• Multi-repo support: Manage multiple GitHub repositories from a single UI
• Isolated sessions: Each coding session runs in its own Docker container with a dedicated git worktree
• Real-time streaming: Watch agent activity live via WebSockets
• Orchestrator mode: Special per-repo coordinator session that can oversee other sessions
• GitHub integration: Branch links, compare views, and PR detection
• Persistent history: All events are stored in PostgreSQL for replay and analysis

• Framework: SvelteKit 2 with Svelte 5
• Database: PostgreSQL with Drizzle ORM
• WebSocket: sveltekit-ws for real-time communication
• Styling: Tailwind CSS
• Testing: Vitest with Playwright
• Runtime: Node.js with adapter-node

• Node.js 20+
• PostgreSQL database
• Docker Desktop (for agent containers)
• GitHub CLI (gh) installed and authenticated (gh auth login)
• Claude credentials in ~/.claude (for Claude Code Agent SDK)

The easiest way to run Agent Manager with PostgreSQL:

# Start all services
docker compose up --build

# Or run in background
docker compose up -d --build

This starts:

• App: http://localhost:3000
• PostgreSQL: localhost:5432 (user: agent_manager, password: agent_manager)

The database schema is automatically initialized on first startup. On subsequent starts, the schema is updated if needed.

To stop:

docker compose down

To stop and remove the database volume (resets all data):

docker compose down -v

npm install

Copy the example environment file:

cp .env.example .env

Edit .env with your PostgreSQL connection string:

DATABASE_URL=postgresql://user:password@localhost:5432/agent_manager

Push the schema to your database:

npm run db:push

cd docker
chmod +x build.sh
./build.sh

npm run dev

Open http://localhost:5173 in your browser.

Agent Manager can be configured via environment variables or a config file at ~/.agent-manager/config.json.

Create ~/.agent-manager/config.json:

{
  "databaseUrl": "postgres://localhost:5432/agent_manager",
  "port": 3000,
  "workspaceRoot": "~/.agent-manager",
  "containerImage": "agent-manager-sandbox:latest",
  "idleTimeoutSeconds": 30,
  "baseSystemPrompt": "Custom base system prompt..."
}

~/.agent-manager/
├── config.json              # Configuration file
├── repos/                   # Bare git mirrors
│   └── owner/
│       └── repo.git
└── worktrees/               # Session worktrees
    └── {sessionId}/

1. SvelteKit App: Serves UI, API routes, and WebSocket server
2. Runner Module: Manages git operations, Docker containers
3. PostgreSQL: Stores repos, sessions, and event streams
4. Docker Containers: Isolated agent execution environments

Connect to /ws for real-time updates.

interface WSMessage {
  v: 1;
  kind: 'event' | 'command' | 'ack' | 'error' | 'subscribe' | 'snapshot';
  sessionId: string | null;
  ts: string;  // ISO-8601
  seq: number;
  payload: object;
}

const ws = new WebSocket('ws://localhost:5173/ws');

// Subscribe to a session's events
ws.send(JSON.stringify({
  v: 1,
  kind: 'command',
  sessionId: null,
  ts: new Date().toISOString(),
  seq: 1,
  payload: {
    type: 'subscribe.session',
    sessionId: 'session-uuid'
  }
}));

• starting: Worktree creation + container boot
• running: Agent actively producing events
• waiting: Agent idle, ready for user input
• finished: Agent exited normally
• error: Agent/container crashed
• stopped: User stopped the session

• Implementer: Focused on code changes
• Orchestrator: Coordinates other sessions (one per repo)

# Run all tests
npm test

# Watch mode
npm run test:unit

# Check types
npm run check

npm run db:push      # Push schema to database
npm run db:generate  # Generate migrations
npm run db:migrate   # Run migrations
npm run db:studio    # Open Drizzle Studio

docker compose up -d --build

This runs the app with PostgreSQL. Data is persisted in a Docker volume. Database migrations run automatically on container startup.

npm run build
node build

With custom port:

PORT=8080 node build

src/
├── lib/
│   ├── components/       # Svelte components
│   ├── server/
│   │   ├── db/           # Database schema and connection
│   │   ├── runner/       # Git, GitHub, Docker modules
│   │   ├── websocket/    # WebSocket handlers
│   │   └── config.ts     # Configuration management
│   └── types/            # TypeScript types
├── routes/
│   ├── api/              # API endpoints
│   ├── repos/[id]/       # Repo detail page
│   ├── sessions/[id]/    # Session detail page
│   └── +page.svelte      # Home (repo list)
└── app.css               # Global styles

docker/
├── Dockerfile            # Agent container image
├── agent-entrypoint.sh   # Container entry script
├── agent-ws-client.js    # WebSocket client for containers
└── build.sh              # Build script

Run gh auth login and follow the prompts.

Ensure Docker Desktop is running.

Check Docker logs: docker logs agent-session-{sessionId}

Ensure the server is running and accessible at the configured port.

MIT