Introducing Rovo CLI (Beta)

James Steven

Rovo CLI (Beta)

Rovo CLI is Atlassian's AI-powered command-line tool for knowledge workers. It runs locally on your computer enabling Rovo to work on any number of local documents, spreadsheets, slides and more. It also combines the power of Rovo with access to the Teamwork Graph CLI, giving you instant access to insights across Jira, Confluence, Bitbucket, Loom, Atlas goals, projects, and more, all from a single command-line interface. Describe what you want in plain language; Rovo CLI handles the rest. More about Teamwork Graph CLI

What you can do with Rovo CLI

Rovo CLI helps you get things done across Atlassian apps without switching between browser tabs or learning complex commands. Common use cases include:

• Catch up on work: Summarize what your team worked on this week, review your open Jira work items, or check sprint progress.
• Find information fast: Search across Confluence pages, Jira work items, Loom transcripts, and connected third-party apps using natural language.
• Take action: Create Jira work items, update Confluence pages, draft documents, and manage your work directly from the terminal.
• Cross-product insights: Pull together information from multiple Atlassian apps in a single query. For example, review a team member's recent pull requests, linked Jira work items, and relevant Confluence pages all at once.
• Meeting preparation: Get pre-meeting briefs that aggregate context from Jira, Confluence, Loom, and calendar data.
• Status updates and reporting: Generate weekly summaries, sprint reports, and project updates automatically.

How Rovo CLI is different from Rovo Dev CLI

• Rovo CLI bundles the Teamwork Graph CLI (TWG CLI), bringing the context you can access across your organization’s Atlassian tools into your terminal. Developers can use that context to investigate issues and write code, while knowledge workers can find answers, draft documents, and plan work. Rovo CLI is the intended successor to Rovo Dev CLI, which remains available during the transition.

How to try out Rovo CLI in Beta

• If you’re already a Rovo Dev CLI customer, you’ll be included in the Beta automatically
• If you’re not a Rovo Dev CLI customer, you can request access to the Beta via this signup: Rovo CLI EAP — EAP/Beta Consent Collection Program

Install and run Rovo CLI

Install on macOS or Linux

Run this command in a terminal:

bash <(curl -fsSL https://teamwork-graph.atlassian.com/cli/rovo-install)

Install on Windows

Run this command in PowerShell:

irm https://acli.atlassian.com/plugins/rovodev/install.ps1 | iex

Teamwork Graph CLI

Rovo CLI comes bundled with the Teamwork Graph CLI. The installer will ask whether you accept the Teamwork Graph CLI license before enabling the bundled TWG command.

The bundled Teamwork Graph CLI is managed by Rovo. Use rovo login to refresh its authentication and update Rovo CLI to receive its matching bundled version. Do not run twg login, twg update, twg uninstall or twg consent against that bundle. If you chose not to enable Teamwork Graph CLI during installation, rerun the installer and accept the license when you are authorized to do so.

Start a Rovo CLI session

Rovo CLI works from the directory in which you launch it. Use a Git repository for the project you want Rovo to inspect or change. Open a new terminal after installation so it picks up the updated command path, then run rovo from your project directory.

Describe a specific outcome, such as “Explain how authentication works in this repository and point me to its tests.” Rovo can ask follow-up questions or request permission to run tools. Check the command, file path and intended change before approving an action; review the results and any file changes before relying on them.

Use /exit to leave the session. Sessions are saved automatically. Use /sessions while Rovo is running to browse saved sessions, or run rovo --restore when starting the CLI to choose one. For a different project, exit and restart Rovo from that project's directory instead of reusing the wrong workspace.

Sign in to Rovo CLI

At first launch, complete the browser sign-in flow if prompted. If you need to re-start the authentication flow, run rovo login.

For the bundled Teamwork Graph CLI, Rovo provisions authentication as part of its own sign-in flow. If the bundled Teamwork Graph CLI cannot authenticate, run rovo login. A separately installed Teamwork Graph CLI has its own sign-in and update lifecycle.

To change accounts or remove Rovo credentials from your machine, run rovo logout and sign in again with the intended account. If access is still missing, check your account's product permissions. See “Get help in Rovo CLI” section for details.

Update Rovo CLI

By default, Rovo CLI checks for an update when it launches and installs a newer version automatically. To request an update manually, run rovo upgrade.

If rovo is not found or an update fails, restart the terminal and see “Get help in Rovo CLI” section for details before rerunning the installer.

Move from Rovo Dev CLI to Rovo CLI

Rovo Dev CLI is becoming Rovo CLI.
Rovo CLI brings all the functionality from Rovo Dev CLI and augments it with Atlassian’s Teamwork Graph, providing an array of new tools to work with your workplace context. This document explains how to migrate your sessions, skills, configuration, mcps, and hooks from Rovo Dev CLI to Rovo CLI.

What changes

	Rovo Dev CLI	Rovo CLI
Command	acli rovodev	rovo
Personal settings folder	~/.rovodev	~/.rovo
Sign in	acli rovodev auth login	rovo login
Usage	Rovo Dev credits	Rovo credits

Step 1: Install Rovo CLI

To install Rovo CLI, see “Install and run Rovo CLI” section for details.

Step 2: Sign in

Run rovo and complete the browser sign-in.

You need to do this even if you're already signed in to Rovo Dev CLI.

Step 3: Copy your settings (optional)

These commands copy your personal configuration, MCP servers, user memory, skills, hooks, subagents and saved prompts from Rovo Dev CLI to Rovo CLI.

Anything that already exists in Rovo CLI is skipped, so nothing you've set up there is overwritten.

macOS or Linux

Create the Rovo CLI directory (if it doesn’t already exist)

mkdir -p ~/.rovo

Core config

if [ -f ~/.rovodev/config.yml ]; then cp -a ~/.rovodev/config.yml ~/.rovo/ sed -i.bak 's/\.rovodev/.rovo/g' ~/.rovo/config.yml && rm ~/.rovo/config.yml.bakfi

MCPs

[ -f ~/.rovodev/mcp.json ] && cp -a ~/.rovodev/mcp.json ~/.rovo/

User Memory

[ -f ~/.rovodev/AGENTS.md ] && cp -a ~/.rovodev/AGENTS.md ~/.rovo/

Prompts

OLD=~/.rovodev; NEW=~/.rovoif [ -f "$OLD/prompts.yml" ]; then sed -n -E "s/^[[:space:]]*-?[[:space:]]*content_file:[[:space:]]*[\"']?([^\"'#]*[^\"'#[:space:]])[\"']?[[:space:]]*(#.*)?$/\1/p" "$OLD/prompts.yml" | while IFS= read -r file; do case "$file" in /*) echo "Kept $file (full path, no copy needed)"; continue ;; esac if [ ! -f "$OLD/$file" ]; then if [ -f "$HOME/$file" ]; then echo "Kept $file (in your home folder, no copy needed)"; else echo "Not found: $file"; fi continue fi if [ -e "$NEW/$file" ]; then echo "Skipped $file (already in Rovo CLI)"; continue; fi mkdir -p "$(dirname "$NEW/$file")" cp "$OLD/$file" "$NEW/$file" echo "Copied $file" done if [ -f "$NEW/prompts.yml" ] && ! cmp -s "$OLD/prompts.yml" "$NEW/prompts.yml"; then cp "$NEW/prompts.yml" "$NEW/prompts.yml.before-migration" fi cp "$OLD/prompts.yml" "$NEW/prompts.yml" echo "Copied prompts.yml"fi

Custom skills, hooks and subagents

# Custom skills, hooks, prompts, and subagents[ -d ~/.rovodev/skills ] && cp -a ~/.rovodev/skills ~/.rovo/[ -d ~/.rovodev/hooks ] && cp -a ~/.rovodev/hooks ~/.rovo/[ -d ~/.rovodev/subagents ] && cp -a ~/.rovodev/subagents ~/.rovo/

Custom commands (if present)

[ -d ~/.rovodev/<custom-command-dir> ] && cp -a ~/.rovodev/<custom-command-dir> ~/.rovo/

Previous session / prompt history

Older sessions might not resume cleanly because they can refer to tools Rovo CLI doesn't have. Use them for reference rather than to carry on where you left off.

[ -d ~/.rovodev/sessions ] && cp -a ~/.rovodev/sessions ~/.rovo/[ -f ~/.rovodev/prompt_history ] && cp -a ~/.rovodev/prompt_history ~/.rovo/[ -d ~/.rovodev/prompt_history ] && cp -a ~/.rovodev/prompt_history ~/.rovo/

Windows (PowerShell)

Create the Rovo CLI directory (if it doesn’t already exist)

$old = "$HOME\.rovodev"; $new = "$HOME\.rovo" if (-not (Test-Path $new)) { New-Item -ItemType Directory -Path $new | Out-Null }

Core config

if (Test-Path "$HOME\.rovodev\config.yml") { $text = [IO.File]::ReadAllText("$HOME\.rovodev\config.yml") -replace '\.rovodev', '.rovo' [IO.File]::WriteAllText("$HOME\.rovo\config.yml", $text)}

MCPs

if (Test-Path "$HOME\.rovodev\mcp.json") { if ((Test-Path "$HOME\.rovo\mcp.json") -and -not (Test-Path "$HOME\.rovo\mcp.json.before-migration")) { Copy-Item "$HOME\.rovo\mcp.json" "$HOME\.rovo\mcp.json.before-migration" } Copy-Item "$HOME\.rovodev\mcp.json" "$HOME\.rovo\mcp.json" -Force}

User Memory

if (Test-Path "$HOME\.rovodev\AGENTS.md") { Copy-Item "$HOME\.rovodev\AGENTS.md" "$HOME\.rovo\AGENTS.md" -Force}

Prompts

if (Test-Path "$old\prompts.yml") { foreach ($line in Get-Content "$old\prompts.yml") { if ($line -notmatch '^\s*-?\s*content_file:\s*["'']?([^"''#]*[^"''#\s])["'']?\s*(#.*)?$') { continue } $file = $Matches[1] if ([IO.Path]::IsPathRooted($file)) { Write-Host "Kept $file (full path, no copy needed)"; continue } if (-not (Test-Path (Join-Path $old $file))) { if (Test-Path (Join-Path $HOME $file)) { Write-Host "Kept $file (in your home folder, no copy needed)" } else { Write-Host "Not found: $file" } continue } if (Test-Path (Join-Path $new $file)) { Write-Host "Skipped $file (already in Rovo CLI)"; continue } New-Item -ItemType Directory -Force (Split-Path (Join-Path $new $file)) | Out-Null Copy-Item (Join-Path $old $file) (Join-Path $new $file) Write-Host "Copied $file" } if ((Test-Path "$new\prompts.yml") -and (Get-FileHash "$new\prompts.yml").Hash -ne (Get-FileHash "$old\prompts.yml").Hash) { Copy-Item "$new\prompts.yml" "$new\prompts.yml.before-migration" -Force } Copy-Item "$old\prompts.yml" "$new\prompts.yml" -Force Write-Host "Copied prompts.yml"}

Custom skills, hooks, prompts and subagents

if (Test-Path "$HOME\.rovodev\skills") { New-Item -ItemType Directory -Force "$HOME\.rovo\skills" | Out-Null Get-ChildItem "$HOME\.rovodev\skills" | Where-Object { -not (Test-Path "$HOME\.rovo\skills\$($_.Name)") } | Copy-Item -Destination "$HOME\.rovo\skills" -Recurse}if (Test-Path "$HOME\.rovodev\hooks") { New-Item -ItemType Directory -Force "$HOME\.rovo\hooks" | Out-Null Get-ChildItem "$HOME\.rovodev\hooks" | Where-Object { -not (Test-Path "$HOME\.rovo\hooks\$($_.Name)") } | Copy-Item -Destination "$HOME\.rovo\hooks" -Recurse}if (Test-Path "$HOME\.rovodev\subagents") { New-Item -ItemType Directory -Force "$HOME\.rovo\subagents" | Out-Null Get-ChildItem "$HOME\.rovodev\subagents" | Where-Object { -not (Test-Path "$HOME\.rovo\subagents\$($_.Name)") } | Copy-Item -Destination "$HOME\.rovo\subagents" -Recurse}

Custom commands (if present)

if (Test-Path "$HOME\.rovodev\<custom command directory>") { New-Item -ItemType Directory -Force "$HOME\.rovo\<custom command directory>" | Out-Null Get-ChildItem "$HOME\.rovodev\<custom command directory>" | Where-Object { -not (Test-Path "$HOME\.rovo\<custom command directory>\$($_.Name)") } | Copy-Item -Destination "$HOME\.rovo\<custom command directory>" -Recurse}

Previous session / prompt history

Older sessions might not resume cleanly because they can refer to tools Rovo CLI doesn't have. Use them for reference rather than to carry on where you left off.

if (Test-Path "$HOME\.rovodev\sessions") { New-Item -ItemType Directory -Force "$HOME\.rovo\sessions" | Out-Null Get-ChildItem "$HOME\.rovodev\sessions" -Directory | Where-Object { -not (Test-Path "$HOME\.rovo\sessions\$($_.Name)") } | Copy-Item -Destination "$HOME\.rovo\sessions" -Recurse}if (Test-Path "$HOME\.rovodev\prompt_history") { $text = [IO.File]::ReadAllText("$HOME\.rovodev\prompt_history") if (Test-Path "$HOME\.rovo\prompt_history") { $text += [IO.File]::ReadAllText("$HOME\.rovo\prompt_history") } [IO.File]::WriteAllText("$HOME\.rovo\prompt_history", $text)}

Step 4: Check your setup

Run rovo from a project folder, then check:

• /mcp shows your MCP servers
• /hooks shows your hooks
• /prompts shows your saved prompts
• /memory user opens your copied memory file

If something's missing, run rovo doctor and see “Get help in Rovo CLI” section for details.

Step 5: Update scripts and automation

If you call Rovo Dev CLI from scripts, CI pipelines or containers, change the command:

Rovo Dev CLI	Rovo CLI
acli rovodev run "<instruction>"	rovo run "<instruction>"
acli rovodev serve <port>	rovo serve <port>
acli rovodev mcp	rovo mcp
acli rovodev doctor	rovo doctor

Step 6: Switch to Rovo CLI

Moving forward, use rovo to run Rovo CLI. You can keep Rovo Dev CLI installed as a fallback until its end of life (early 2027).

Connect to an MCP server in Rovo CLI

Rovo CLI supports Model Context Protocol (MCP) servers. An MCP server can give Rovo access to tools and data from a local process or a remote service.

Only connect servers you trust. A server may receive context from your requests, use credentials you provide, and return instructions that influence how Rovo uses its tools. Make sure you have the necessary rights and consents for Atlassian to use connected data, and follow the terms and policies that apply to each data source.

What is MCP?

MCP is a standardized framework that lets AI large language models connect to external data, tools, and services like databases, APIs, file systems, and other external resources.

By using MCP to connect Rovo to other data sources, you can enhance the quality of AI-generated code by providing the model with rich, relevant context from outside your Atlassian site.

Make sure you have all the necessary consents and rights to enable Atlassian to use these connected data sources. You are responsible for complying with all applicable terms and policies governing the use of these connected data sources.

Manage MCP servers

Interactive mode

Use /mcp in interactive mode to manage MCP servers.

This opens an interactive interface where you can view your MCP servers, see their status and available tools, and enable or disable specific servers.

MCP configuration file

Rovo CLI stores MCP server configurations in ~/.rovo/mcp.json. Run rovo mcp to edit in your default editor.

Structure
{ "mcpServers": { "server-name": { "command": "command-to-run", "args": ["arg1", "arg2"], "env": { "ENV_VAR": "value" }, "transport": "stdio" }, "http-server": { "url": "https://example.com/mcp", "headers": { "Authorization": "Bearer YOUR_API_KEY" }, "transport": "http" "enable_instructions": true }, "sse-server": { "url": "https://example.com/mcp/sse", "transport": "sse" } }}




Transports

MCP supports three transport methods:

• stdio: Communication via standard input/output (most common)
• http: Communication via HTTP requests
• sse: Communication via Server-Sent Events

Disable specific MCP servers

Disable specific MCP servers in your main configuration file (~/.rovo/config.yml):

mcp: # Path to MCP configuration file mcpConfigPath: "~/.rovo/mcp.json" # List of globally disabled MCP server signatures disabledMcpServers: - "server-name-to-disable"

MCP server instructions

The MCP protocol allows a server to return optional server-level instructions as part of its initialization response. These instructions are authored by the server to help agents understand how to use that server's tools correctly (for example, reading a required configuration resource before invoking tools, calling a setup tool once per session, or following a domain-specific workflow).

By default, Rovo CLI surfaces a user-configured server's instructions into the agent's system prompt.

To prevent a specific server's instructions from being passed to the agent, set "enable_instructions": false on that server's entry in mcp.json:

{ "mcpServers": { "my-trusted-server": { "url": "https://example.com/mcp", "transport": "http", "enable_instructions": false } }}

 Notes:

• enable_instructions is configured per server, so you can trust one server's instructions while leaving others disabled.
• When the field is absent or set to true, the server's instructions are surfaced to Rovo.
• You can disable this for MCP servers that are untrustworthy or misbehaving.

Rovo CLI commands

Command line

Commands available from your terminal before starting interactive mode:

Run Rovo CLI

rovo run - Start Rovo CLI in interactive mode.

rovo run [instruction] - Execute a single instruction (non-interactive mode).

rovo run --worktree [name] - Run Rovo CLI in a Git worktree. Optionally, specify a name. If you don’t specify a name, a timestamp-based name is automatically generated.

rovo run --web - Start Rovo CLI in web UI mode instead of terminal UI.

rovo run --restore [session ID] - Run Rovo CLI and restore the last session from the current workspace. Pass in a session ID to restore a specific session, or use the flag without a value to restore the most recent session.

rovo run --yolo - Runs Rovo CLI in YOLO mode, without asking permission for tool use (use with caution).

Get help

rovo --help - Show flags and commands.

rovo <command> --help - Get detailed help about specific commands (for example, you could use rovo config --help).

Server mode

rovo serve [port] - Starts Rovo in server mode on the specified port.

Configuration file

rovo config - Opens the configuration file in your default editor.

rovo run --config-file <path-to-config.yml> - Create a new configuration in the specified directory and use its settings for Rovo CLI.

Model Context Protocol (MCP) servers

rovo mcp - Opens MCP server configuration file in your default editor.

Interactive mode

To view all available commands when you’re in Rovo CLI’s interactive mode, use /help.

Session management

/new - Create a new session with an optional title.

/sessions new - Create a new session with default title.

/sessions new [title] - Create a new session with custom title.

/sessions fork - Fork the current session with default title.

/sessions fork [title] - Fork the current session with custom title.

/sessions rename [title] - Rename the current session.

/sessions rename [session_id] [new_title] - Rename a specific session.

/clear - Clear the current session's message history (cannot be undone).

/prune - Reduce token size while retaining context (removes tool results).

See “Manage sessions in Rovo CLI” section for details.

Saved prompts

/prompts - Opens an interactive menu to view and select saved prompts.

/prompts [title] - Runs the prompt you specify.

/prompts [title] [extra_information] - Appends the extra information you specify to the end of your saved prompt and runs. Extra information can also be used to specify parameters that are expected by the saved prompt.

Memory

/memory - Edit the current directory’s memory file.

/memory user - Edit your user memory file.

/memory init - Rovo analyzes the current project and generates content for your project file.

/memory reflect - Analyze current conversation and integrate insights into memory.

Jira

/jira - Lists assigned, unresolved issues from configured projects

/jira global - Configure global Jira project for all workspaces.

/jira local - Configure local workspace Jira project override.

/jira local remove - Remove local workspace override.

/jira disable - Disable Jira integration.

Productivity

? - Show all available shortcuts.

/ask - Send a prompt in ask (read-only) mode without permanently switching modes.

/copy - Copy last agent response to clipboard.

/copy conversation [limit] - Copy conversation history to clipboard.

/plan - Switch to plan mode to create an implementation plan before making changes.

/full-context - Gather project context from Atlassian tools using the full-context-mode skill (when enabled).

/research - Conduct deep research using domain-focused subagents (when enabled).

/yolo - Toggle YOLO mode, bypass confirmations for file operations and shell commands (use with caution).

System

/status - Show CLI status, version, account details, and model.

/config - View and edit Rovo configuration.

/mode - Display and select from available agent modes.

/models - Switch between available AI models.

/feedback - Provide feedback or report bugs.

/mcp - Manage MCP servers.

/directories - Manage allowed external directories for file access.

/subagents - Manage subagent profiles (when enabled).

/changelog - Display changelog and release notes.

/hooks - Manage event hook configurations.

/efficiency - Set the efficiency level for the current session.

Exit

/exit - Quit Rovo (also /quit, /q, exit, quit, q).Understand Rovo CLI costs, usage, and billing

Get help in Rovo CLI

Interactive mode

/help - Show commands and general guidance.

/help <query> - Get responses from Rovo about specific functionality.

/<command> help - Get detailed help about specific commands (for example, you could use /sessions help or /prompts help).

Command line

rovo --help - Show flags and commands.

rovo <command> --help - Get detailed help about specific commands (for example, you could use rovo config --help).

rovo doctor - Shows version, installation paths for Rovo CLI and Teamwork Graph CLI

rovo doctor --twg - Shows version, installation paths and authentication status for Teamwork Graph CLI

Troubleshooting

• rovo is not found after installation: open a new terminal so it sees the updated PATH. On Windows, use Get-Command rovo in the new PowerShell session to check whether the command is available.
• Sign-in fails or Rovo shows the wrong account or site: run rovo login and complete browser sign-in. In a session, use /status to check the account and selected site. Check your access to the underlying product if a specific Jira or Confluence item is unavailable.
• TWG commands fail: run rovo doctor --twg to check the bundled command and its connection. If the bundle cannot authenticate, run rovo login. If you declined the TWG license, rerun the Rovo installer and accept the license when authorized.
• Rovo is working in the wrong project: use /exit, change to the intended Git repository and start rovo again. A non-Git directory is not the recommended workspace; create a repository first.
• A tool or model is unavailable: review the error, the current account/site in /status, and the remediation section of rovo doctor. A failed tool may also require product permission or a configured integration.

If the issue remains, record the Rovo version (rovo --version), your operating system, the steps to reproduce it, what you expected and what happened. Run rovo doctor and include its report when contacting support. The report does not include credentials, but it can include your account email, site and install paths; remove those identifiers if the ticket is public. Do not attach raw logs as the default diagnostic artifact.

Understand Rovo CLI costs, usage, and billing

Rovo CLI uses Rovo credits (not Rovo Dev credits) for billable AI work. Credits are drawn from your organization’s shared pool, which your admin manages.

Your organization’s eligible Atlassian subscriptions contribute to that pool. The included allowance depends on your subscriptions and plans, and resets monthly, in line with your billing cycle. Unused included credits do not roll over. See How Rovo credits work for current allowances and pricing.

What affects Rovo CLI usage?

The credits used by a Rovo CLI task can vary with the work it performs. Factors can include the model used, the amount of context processed, reasoning and tool use. A multi-step task may use more credits than a short request.

A model’s context window or multiplier isn’t a price. It describes model capability, not credit cost. Check your organization’s recorded usage and the current Rovo credit guidance when planning costs.

Check your organization’s usage

Organization and billing admins can check Rovo credit usage in Atlassian Administration:

1. Go to admin.atlassian.com and select your organization.
2. Select Insights, then Platform usage.
3. Select Rovo credits.

The view shows your organization’s allowance and usage. Your admin can use it to review usage across the organization and plan for additional consumption.

What happens when the allowance runs out?

It depends on how your admin has set up extra usage for your organization. For details, see How Rovo credits work.

Tomislav Tobijas

Hi @James Steven ,

Any chance you can check this image at the top of the article? Seems to be broken 👀