# Overview (/agent)

Jan Agent is an AI agent that lives in your terminal. You give it a task in plain language, and it
reads files, edits them, runs commands, and searches the web until the work is done - asking for
your approval before anything touches your machine.

It uses the providers you have already configured in Jan Desktop, so if you're a Jan user there is
nothing new to sign up for.

```bash
jan
```

That single command opens the interactive console in whatever directory you're in.

## Jan Agent and Jan Desktop [#jan-agent-and-jan-desktop]

They're two front ends onto the same stack, built for different jobs. Jan Desktop is where you run
models on your own hardware and work in a GUI. Jan Agent is where you point a model at a folder and
let it work.

| | Jan Desktop | Jan Agent |
| --- | --- | --- |
| Interface | Desktop app | Terminal, interactive or headless |
| Where models run | Locally via llama.cpp or MLX, or a cloud provider | Cloud providers, or any OpenAI-compatible endpoint |
| Works on | Conversations, projects, and files you attach | A project folder on disk |
| Files and shell | Through MCP servers you add | Built in - read, write, edit, and run commands, each gated by approval |
| MCP servers | Yes | Yes, the same ones |
| Skills and memory | Yes | Yes, the same ones |

Neither replaces the other. A common setup is Jan Desktop serving a local model, with Jan Agent
pointed at it - see [running against local models](/agent/providers#your-own-hardware).

Provider settings, MCP servers, [skills, and memory](/agent/skills)
are all shared, so anything you set up in one is already there in the other.

## Install [#install]

<Callout type="warning">
Jan Agent is a preview. The installer on `dev` pulls from the `agent-nightly` channel - expect
nightly-quality builds.
</Callout>

<Tabs items={['macOS / Linux', 'Windows']}>
  <Tabs.Tab>
```bash
curl -fsSL https://delta.jan.ai/jan-cli/install-jan-agent.sh | bash
```
  </Tabs.Tab>
  <Tabs.Tab>
```powershell
irm https://delta.jan.ai/jan-cli/install-jan-agent.ps1 | iex
```

Installs to `%USERPROFILE%\.local\bin`. To also add it to your user `PATH`:

```powershell
& ([scriptblock]::Create((irm https://delta.jan.ai/jan-cli/install-jan-agent.ps1))) -AddToPath
```
  </Tabs.Tab>
</Tabs>

Then check it landed:

```bash
jan --version
```

The [Quickstart](/agent/quickstart) covers connecting a provider and finishing a first task.
Looking for the desktop app instead? <Link href="https://jan.ai/download" target="_blank" rel="noopener noreferrer">Download Jan Desktop</Link>.

## What it can do [#what-it-can-do]

- **Read and change a project** - open files, make targeted edits, create new ones.
- **Run commands** - build, test, grep, and read the output to decide what to do next.
- **Search the web** - look things up mid-task when the answer isn't in your project.
- **Use your MCP servers** - every connector configured in Jan Desktop is available here too.
- **Follow your project's skills** - reusable procedures it loads when a task calls for them.
- **Remember across sessions** - durable facts about the project, kept as files you can review.
- **Delegate** - split large jobs across [subagents](/agent/subagents) that work in parallel.
- **Keep working toward a goal** - `/goal` keeps it going until a condition you set is true.

<Callout type="info">
Jan Agent ships no inference engine of its own, so a model always runs somewhere else. That can be a
cloud provider, or your own machine - point it at any OpenAI-compatible endpoint, such as Jan
Desktop's [local API server](/desktop/api-server), with `jan config set --base-url`.
</Callout>

## Get started [#get-started]

<DocCards>
  <DocCard title="Quickstart" href="/agent/quickstart" icon={<Rocket size={20} />}>Install Jan Agent, connect a provider, and finish your first task.</DocCard>
  <DocCard title="Interactive console" href="/agent/console" icon={<SquareTerminal size={20} />}>Slash commands, keyboard shortcuts, and how a session works.</DocCard>
  <DocCard title="Tools & permissions" href="/agent/permissions" icon={<Wrench size={20} />}>What the agent can do, and how approval keeps you in control.</DocCard>
  <DocCard title="Configuration" href="/agent/project-config" icon={<Settings size={20} />}>Providers, `agent.toml`, and per-project instructions.</DocCard>
  <DocCard title="Subagents" href="/agent/subagents" icon={<Users size={20} />}>Delegate parts of a task to agents that run in parallel.</DocCard>
  <DocCard title="CLI reference" href="/agent/cli" icon={<Terminal size={20} />}>Every flag and subcommand, including headless runs for scripts and CI.</DocCard>
</DocCards>

## Staying in control [#staying-in-control]

The agent edits files and runs commands without stopping to ask. File paths are checked against the
project root, and anything in `[tools] deny` is refused outright - but
shell commands are not sandboxed by default, so one runs with your own access.

Three ways to change that:

- **Plan mode** (`jan --plan`) makes the session read-only. The agent investigates and proposes, but
  cannot change anything.
- **Safe mode** (`jan --safe`) asks before every write and shell command, instead of auto-approving
  them.
- **Sandbox** (`jan --sandbox`) confines shell commands to the project with an OS sandbox. Off by
  default on the CLI, always on in the desktop app.

See [Tools & permissions](/agent/permissions) for the full picture.