# Show HN: atl, a Rust CLI for Jira, Confluence and Bitbucket with ~15ms overhead

> Source: <https://github.com/racetozero/atlassian-toolkit>
> Published: 2026-11-15 19:06:04+00:00

**Use Jira, Confluence and Bitbucket from your terminal, or let your AI agent use them for you.**

`atl` is one command-line tool for Atlassian, and it is agent ready from the first command. Claude Code, Codex, Cursor and other agents can find issues, update pages and review pull requests with the same commands you type, through a JSON mode that never stops to ask a question, a built-in MCP server, and installable skills.

It works with Jira, Confluence, Bitbucket, Jira Service Management, Trello and Atlassian Admin, on Atlassian Cloud and on self-hosted Data Center. The commands are the same on both.

```
atl jira issue list -a me -s ~Done
```

That command lists your open issues. Most of what you do in `atl` reads like that.

On macOS or Linux:

```
curl -LsSf https://raw.githubusercontent.com/racetozero/atlassian-toolkit/main/install.sh | sh
```

On Windows:

```
powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/racetozero/atlassian-toolkit/main/install.ps1 | iex"
```

Or use Homebrew (`brew install racetozero/tap/atl`) or Cargo (` cargo install atl`).

`atl` is a single file with nothing else to install. When a new version is out, `atl` prints a short notice after a command, and `atl update` installs it.

Then sign in with `atl auth login` ([details](#sign-in)).

- **Agent ready.** Add`--agent` and every command prints one JSON line. Nothing prompts. When a value is missing, the error lists the valid choices, so the agent gets it right on the next try. Destructive commands wait for`--yes` .
- **MCP built in.**`atl mcp` serves 136 Jira, Confluence, Bitbucket, JSM, Trello and Admin tools to any MCP client, with no extra server to install.
- **Skills for your agent.** One core skill and one per product teach the commands. Install them with`npx skills add racetozero/atlassian-toolkit` or`atl skill --install` .
- **Safe by default for automation.** A read-only login blocks every write in the CLI, the MCP server and the SDKs alike.
- **Cloud and Data Center.** One tool and one set of commands for both, so a migration does not change your scripts.
- **Every API, not only the common ones.**`atl api` reaches all 3,085 public Atlassian REST operations with your normal login.
- **Confluence in Markdown.** Pull pages to Markdown, edit them in your editor, keep them in git, and push them back.
- **Knows your branch.** On`feature/ABC-123-login-fix` ,`atl jira issue view` opens`ABC-123` without the key.
- **Output for the reader.** Tables in a terminal, JSON in a pipe, plus CSV,`--select` and`--jq` when you need them.
- **A full-screen browser.**`atl browse` lets you move through issues, filters and spaces with the arrow keys.
- **Every sign-in your company uses.** API tokens, scoped tokens, OAuth, personal access tokens, SSO cookies and client certificates.
- **Build on it.** The same tasks are in SDKs for Python 3.11+, TypeScript on Node, Bun and Deno, browser WebAssembly, and Rust.
- **One fast file.** A single native binary with nothing else to install.`atl update` keeps it current.

- **Developers.** You can update a ticket, open a pull request and check a build without leaving your editor. If your branch is named`feature/ABC-123-login-fix` ,`atl` knows you're working on`ABC-123` , so you don't type the key.
- **People who write docs.** Write Confluence pages in Markdown, in your own editor and in git.`atl` converts them to Confluence format and back. You can export a whole page tree to a folder and publish it again later.
- **Support and service desk teams.** Read the queue, reply to customers, approve requests and see how much SLA time is left.
- **Admins and automation.** Every command prints JSON when its output goes to a script. There are SDKs for Python, TypeScript and Rust, and a mode made for AI coding agents.

**Start your day.** See what's assigned to you, then open the issue for the branch you're on:

```
atl jira issue list -a me -s ~Done
atl jira issue view
```

**Move work along.** Change the status, leave a comment, or move several issues at once:

```
atl jira issue move ABC-12 Done --comment "Fixed in v2.3"
atl jira issue move ABC-12 ABC-13 ABC-14 "In Review"
```

If you leave out the status, `atl` lists the ones you can choose. When `atl` needs a value you didn't give, it shows the options and lets you pick one.

**Report a bug from a file you already wrote:**

```
atl jira issue create -p ABC -t Bug -s "Login fails on Safari" --body-file bug.md
```

**Keep docs in Markdown.** Pull a page down, edit it, and push it back. `atl` updates the version number for you.

```
atl confluence page get DOCS:Handbook > handbook.md
atl confluence page update DOCS:Handbook --file handbook.md
```

To keep a whole section of your wiki in a git repository:

```
atl confluence page export DOCS:Handbook -r --dest docs/
atl confluence page push docs/
```

**Ship code.** Open a pull request from your current branch, check its builds, and merge:

```
atl bitbucket pr create -t "Fix login on Safari"
atl bitbucket pr checks 42
atl bitbucket pr merge 42 --strategy squash
```

**Handle the service desk:**

```
atl jsm request list --desk HELP
atl jsm request approve HELP-7
```

**Look around.** `atl browse` opens a full-screen view of your issues, filters and Confluence spaces in the terminal. You can move through issues with the arrow keys, preview them, and change their status.

To see every command, read [the command guide](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/commands.md) or add `--help` to any command.

The everyday commands cover common work. For everything else, `atl api` gives you every public Atlassian REST API: 3,085 operations, built from Atlassian's own API specs. You use your normal login, and you don't write any HTTP code.

```
atl api jira issues get-issue --issue-id-or-key ABC-12
atl api jira get /rest/api/3/serverInfo
atl auth login
```

A short form asks which product you use, its address, and your token. `atl` checks the token with the server before it saves it, then keeps it in a config file in `~/.config/atl` that only you can read. There is no keychain dialog, so agents and scripts never stop to wait for one.

`atl` supports the ways companies usually sign in to Atlassian:

- **Cloud:** API tokens, scoped tokens and single sign-on through OAuth.
- **Data Center:** personal access tokens, passwords, SSO session cookies and client certificates.

In CI, you can set environment variables instead of signing in. [Sign-in details](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/auth.md).

`atl` changes its output for the reader. In a terminal you get tables and readable text. In a pipe you get JSON. With `--agent`, every command prints one short JSON line, and `atl` never stops to ask a question. This makes it a good tool for AI coding agents such as Claude Code and Codex.

If an agent leaves out a value, the error lists the values it can use, so the agent can retry once and succeed.

To keep an agent from changing anything, give it a read-only login (`atl auth login --read-only`). The check is in `atl`'s core, so the same rule covers the CLI, the MCP server and the SDKs.

Agent skills teach your agent the commands. There is one core skill and one for each product. Install them with the [skills](https://github.com/vercel-labs/skills) CLI, which works with Claude Code, Codex, Cursor and other agents, or with `atl` itself:

```
npx skills add racetozero/atlassian-toolkit     # or: bunx skills add racetozero/atlassian-toolkit
atl skill --install                             # writes them to .claude/skills/
```

`atl mcp` also runs an MCP server for tools that use the Model Context Protocol. [More for agents](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/agent-mode.md).

The CLI is built on a library, and you can use the same library in your own code. It is available for Python, TypeScript (Node.js, Bun, Deno and browsers) and Rust. A task has the same path in every language as in the CLI: `atl jira issue list` is `client.jira.issue.list(...)`. The arguments and results are typed, and Python has an asyncio client too.

``` python
import atl_sdk

issues = atl_sdk.Client().jira.issue.list(project='ABC').issues
js
import { Client } from "atlassian-toolkit"

const { issues } = await Client.fromEnv().jira.issue.list({ project: "ABC" })
```

`atl` adds little time to a request. Against a real Jira Cloud site, `atl jira issue view` takes 222 ms at p50 and 307 ms at p99 (50 runs), and almost all of that time is the server's response.

The table shows `atl`'s own cost. Each time is one `atl` process, from start to exit, against a mock server on the same machine that answers at once. The bulk move is different: each request waits 100 ms, as on a remote site, and `atl` sends up to 8 requests at a time, so moving 8 issues takes about as long as moving one.

| Command | p50 | p99 | 
|---|---|---|
| `atl --version` | 9 ms | 18 ms | 
| `atl --help` | 8 ms | 18 ms | 
| `atl convert --to adf` (Markdown to ADF) | 9 ms | 23 ms | 
| `atl convert --from storage --to markdown` | 9 ms | 22 ms | 
| `atl schema jira.getIssue` | 11 ms | 16 ms | 
| `atl api jira issues get-issue --dry-run` | 11 ms | 25 ms | 
| `atl mcp` : start and list the tools | 11 ms | 27 ms | 
| `atl mcp` : start and search operations | 17 ms | 56 ms | 
| `atl jira issue list` | 16 ms | 30 ms | 
| `atl jira issue view` | 15 ms | 27 ms | 
| `atl api jira issues get-issue` | 18 ms | 82 ms | 
| `atl confluence page get` | 14 ms | 25 ms | 
| `atl jira issue move` with 8 issues, 100 ms per request | 225 ms | 267 ms | 

Measured with `just bench` on an Apple M4 (10 cores) with macOS 27, using the release build: 500 runs of each local command, 300 of each command that calls the server, and 100 of the bulk move. The median peak memory of each command is 21 MiB or less.

- [Commands](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/commands.md) : every command, with examples
- [Signing in](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/auth.md) : tokens, OAuth, SSO and the config file
- [The `atl api` commands](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/api.md) : output formats, errors, retries and debugging
- [Agents and MCP](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/agent-mode.md)
- [SDKs](https://github.com/racetozero/atlassian-toolkit/blob/main/docs/sdk.md)
- [Contributing](https://github.com/racetozero/atlassian-toolkit/blob/main/CONTRIBUTING.md)

MIT