Quick Start

Two ways to drive jackin'

jackin' has two surfaces and you'll use both — but very differently:

jackin console — the interactive operator console (TUI). The simplest and most convenient surface, and the one most operators stay on day-to-day. Today it covers launching agents (the load flow), managing workspaces (workspace), and editing the per-workspace auth and env tables (config for those scopes). The remaining CLI subcommands — hardline, eject, exile, purge, global mounts and global env, multi-session preview — are not in the console yet and live on the CLI for now; they will land in the console as the TUI grows feature by feature.
jackin load and the rest of the CLI — the advanced, scriptable surface. Use it when you want a saved one-liner, an automation script, a specific niche flag the console doesn't expose, or a feature the console doesn't yet have. There is no feature parity between the two on purpose: new flags land on the CLI first.

The expectation is most people use the TUI, and reach for the CLI only when they need it.

The walkthrough below starts with jackin load because it is the shortest one-shot demonstration of jackin' isolation model — install, load, see for yourself that the agent is now running in an isolated world it can't escape. Once that shape clicks, the operator console is where you stay for daily work.

Load your first agent (CLI)

In jackin', the first thing you choose is usually a role. That is the tool profile you want to run. agent-smith is the default starter role included by this project.

Navigate to your project directory
```
cd ~/Projects/my-app
```
Load an agent
```
jackin load agent-smith
```
The first time you run this, jackin' will:
- Pull the construct base image
- Clone the agent-smith role repository
- Build a derived Docker image with Claude Code installed
- Create an isolated Docker network
- Launch the container with your current directory mounted
You're inside

Claude Code starts automatically with full permissions inside the container. Your project directory is mounted at the same path, so the agent sees the same file layout you do.
Exit when done

Press Ctrl+C or type /exit in Claude Code to leave. The container stops, but its state is persisted for next time.

If you already know you want a more specialized role, swap agent-smith for something else such as the-architect.

Move to the operator console for daily use

Once you've seen jackin load work end-to-end, switch to the console for everyday work:

jackin console

This opens the operator console — a TUI where you can:

Pick from saved workspaces or use the current directory
Preview the final directory mounts for the highlighted role before loading it
Choose which role and agent to load
Manage saved workspaces, env vars, and auth without remembering flag syntax

The console is the default daily driver. It covers the common cases of every CLI subcommand. Reach for the CLI when you want a scripted one-liner, a non-interactive run (CI, automation), or a specific advanced flag — jackin load --rebuild, jackin workspace edit … --mount-isolation …, that kind of thing.

See jackin console for the full reference, including the bare-jackin shortcut.

Reconnect to a running agent

If you close your terminal but the agent is still running:

jackin hardline agent-smith

This reattaches your terminal to the running container's session. hardline is a CLI-only flow today.

Stop an agent

# Stop a specific agent
jackin eject agent-smith

# Stop ALL running agents
jackin exile

Common workflows

# Open the console once
jackin console

# Pick a workspace, pick a role, press Enter — you're inside.
# Eject from the same console row when you're done.

The console is the default surface for this flow. The CLI tabs below show the equivalent one-liners for scripts and automation.

# Start of day — load agent into your project
jackin load agent-smith ~/Projects/my-app

# Work with Claude Code inside the container...

# End of day — stop the agent
jackin eject agent-smith

# Save workspaces for your projects
jackin workspace create frontend --workdir ~/Projects/frontend --mount ~/Projects/frontend
jackin workspace create backend --workdir ~/Projects/backend --mount ~/Projects/backend

# Load agents into different workspaces
jackin load agent-smith frontend
jackin load agent-smith backend

# Both agents run simultaneously in isolated containers.
# In the console, those workspaces appear in the manager list and you
# launch them by selecting a row.

# Same project access boundary, different tool profiles
jackin workspace create monorepo --workdir ~/Projects/monorepo --mount ~/Projects/monorepo

jackin load agent-smith monorepo
jackin load the-architect monorepo

# Same files, different environment and plugins.
# In the console, switch the role from the same workspace row.

# Mount a reference codebase as read-only
jackin load agent-smith ~/Projects/my-app \
  --mount ~/Projects/shared-lib:/shared:ro

Next steps

Learn the Core Concepts behind jackin' architecture
Try the jackin console reference — the daily-driver TUI
Set up Workspaces for your projects
Understand the Security Model