# Quick Start (https://jackin.tailrocks.com/getting-started/quickstart/)
## Two ways to drive jackin❯ [#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) [#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.
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.
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 [#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
See [`jackin console`](/commands/console/) for the full reference, including the bare-`jackin` shortcut.
## Reconnect to a running agent [#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 [#stop-an-agent]
```bash
# Stop a specific agent
jackin eject agent-smith
# Stop ALL running agents
jackin exile
```
## Common workflows [#common-workflows]
```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.
```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
```
```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.
```
```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.
```
```bash
# Mount a reference codebase as read-only
jackin load agent-smith ~/Projects/my-app \
--mount ~/Projects/shared-lib:/shared:ro
```
## Next steps [#next-steps]
* Learn the [Core Concepts](/getting-started/concepts/) behind jackin❯ 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/)