---
title: Quick Start
description: Load your first agent in under a minute
---
import { Aside, Steps, TabItem, Tabs } from '@astrojs/starlight/components'


## 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's 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.

<Steps>
1. **Navigate to your project directory**

   ```bash
   cd ~/Projects/my-app
   ```

2. **Load an agent**

   ```bash
   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

3. **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.

4. **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.
</Steps>
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:

```bash
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

<Aside type="tip">
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.
</Aside>

See [`jackin console`](/commands/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:

```bash
jackin hardline agent-smith
```

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

## Stop an agent

```bash
# Stop a specific agent
jackin eject agent-smith

# Stop ALL running agents
jackin exile
```

## Common workflows

<Tabs>
<TabItem label="Daily development (console)">

```bash
# 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.

</TabItem>

<TabItem label="Daily development (CLI)">

```bash
# 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
```

</TabItem>

<TabItem label="Multiple projects">

```bash
# 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.
```

</TabItem>

<TabItem label="One workspace, different roles">

```bash
# 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.
```

</TabItem>

<TabItem label="Read-only access">

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

</TabItem>
</Tabs>
## Next steps

- Learn the [Core Concepts](/getting-started/concepts/) behind jackin's architecture
- Try the [`jackin console`](/commands/console/) reference — the daily-driver TUI
- Set up [Workspaces](/guides/workspaces/) for your projects
- Understand the [Security Model](/guides/security-model/)
