🐕 barkcli

The management layer for AI agents.

You decide what gets built. Agents propose plans, do the work, and report back. barkcli runs the pipeline: intake → plan → dispatch → review → merge. Tasks, specs, memory, skills, and agent runs live in your repo — no cloud, no accounts, no subscriptions.

Install · Quick Start · Docs · Web App · Live Site · Live Web Demo · Comparisons · Discussions

---

Table of Contents

• Why barkcli?
• Features
• Screenshots
• Install
• Quick Start
• The Autopilot Loop
• CLI Reference
• AI Agent Integration
• Interfaces
• Documentation
• Benchmarks & Comparisons
• Architecture
• Development
• Roadmap
• Contributing
• Community
• License

---

Why barkcli?

Intent in, plans out. barkcli is the management layer for AI agents: humans write intent, agents propose plans, each agent works in an isolated git worktree, your tests are the acceptance gate, and only passing branches merge. Tasks, specs, memory, skills, and agent runs live in your repo — no cloud, no accounts, no subscriptions.

• Tasks are files. Boards are plain YAML committed to your repo. Diff them, merge them, grep them, roll them back — exactly like code.
• One binary, four interfaces. CLI, terminal UI (ratatui), web app (axum), and a VS Code Custom Editor. Same data, every surface.
• AI agents in the loop. 71 MCP tools let Claude Code, OpenCode, and Cursor read tasks, claim work, and update progress — with full project context.
• Local-first, free core. No accounts, no subscriptions to use it. Works fully offline. MIT licensed — your data never leaves your machine. A hosted team layer (multiplayer, cloud sync, analytics) is planned at $99/month per team.

---

Features

🧠 Mind	Compiled project snapshot — health, blockers, stale work, next actions. One command answers "what's happening?".
📋 Board	Columns, priorities, labels, assignees, checklists, comments, effort, due dates, reminders. Drag-and-drop in the web app.
🔗 Spec Traceability	Specs → requirements → code. Every card links to its spec and to the code that implements it.
🛠 MCP Server	71 tools for AI coding agents — board, task, memory, specs, orchestration, sessions. barkcli mcp.
🤖 Autopilot	Intent → plan gate → dispatched packets → review → merge gate. Or go fully autonomous: barkcli run "<intent>" --agents 3 --yes — parallel agents in worktrees, your tests as the gate, merge train for the winners.
🧠 Memory	Four-tier local memory + project facts that persist across sessions. Hybrid search.
📦 Skills Registry	Playbooks injected into agent prompts on trigger matches. Install from any git repo (skills install owner/repo), pinned in a committed skills.lock (rev + sha256), publish back via PR.
📅 Sprints	Time-boxed planning with velocity tracking.
🎯 Code Context	Symbol search (barkcli code), file-to-card mapping, git-aware refresh.
⏱ Timeline	Checkpoints, undo, diff, blame, validate, doctor. Your board, version-controlled.
🔀 Import/Export	YAML and JSON. Migrate from Linear, Jira, Trello, GitHub Projects.

---

Screenshots

Mind — the compiled project snapshot	Board — the work, with spec traceability

Brain — the memory knowledge graph	Calendar — deadline-first

Try it live without installing — the Web demo runs the full interface on demo data (every interaction works), or watch a recorded 3-agent run in the real Mind view — live agent rows, gate verdicts, and the merge train.

---

Install

One-liner (macOS & Linux)

curl -fsSL https://github.com/AkshatNaruka/barkcli/releases/latest/download/install.sh | sh

Homebrew

brew tap AkshatNaruka/barkcli && brew install barkcli

Cargo

cargo install barkcli

Binary releases

Download prebuilt binaries for macOS (Intel + Apple Silicon), Linux, and Windows from the Releases page.

Windows: a native PowerShell installer (install.ps1) is also available.

---

Quick Start

# 1. Init once per project (creates .board/, git hooks, spec sync, context autosync)
barkcli init

# 2. Create a board
barkcli create my-project

# 3. Add tasks (board-agnostic by default)
barkcli add "Fix login bug" -p high
barkcli add "Write E2E tests" -l backend

# 4. Work the board
barkcli list              # see all tasks
barkcli move fix-login-bug doing
barkcli done fix-login-bug

# 5. Open the web app (also daemon-safe: --open, --daemon, --stop)
barkcli serve --open

That's it. Your tasks are now YAML files in .board/ — commit them and they're version controlled.

---

The Autopilot Loop

You (intent)  →  barkcli (plan)  →  Agent (work)  →  barkcli (review)  →  You (merge)
     ←──────────────  memory, specs, context persist across runs  ──────────────→

1. Intake — describe what you want in plain language. barkcli intake "Add OAuth login".
2. Plan — agents propose a decomposition; you approve, edit, or reject. barkcli plan <card>.
3. Dispatch — scoped packets (with file context + skills) go to agents. barkcli dispatch.
4. Review — completed work is validated before it lands. barkcli review.
5. Merge — you merge when review passes.

Read the full Autopilot guide.

Or: one prompt to merged code

barkcli run "ship the settings redesign" --agents 3 --yes

The autonomy loop plans the intent into tasks, spawns up to N agents into isolated worktrees, watches each transcript, and runs your project's own tests as the acceptance gate:

• Done means the gate passed in the worktree — never that the agent said so. A crashed agent with no changes and a no-op gate still fails.
• Gate-passing branches ride a merge train in finish order; a conflicted branch re-queues and re-runs solo once the pool drains, against a frozen main — merges converge instead of thrashing.
• Every verdict is recorded in the run report (parallel, workers_peak, merged_branches) and in cross-session memory, so the next run doesn't repeat the last one's mistakes.

Watch it live in the web app's Orchestrate view (/api/run/live), or read the command reference.

---

CLI Reference

Project commands
  barkcli init                  Initialize .board/ + config + git hooks
  barkcli create <name>         Create a board
  barkcli list / ls             Table of all boards
  barkcli status                Cross-board column summary
  barkcli validate              Validate all .board files
  barkcli doctor                Validate + auto-fix
  barkcli export <name> <fmt>   Export board (yaml/json)
  barkcli import <name> [file]  Import board
  barkcli today                 Agenda: overdue / today / next 7 days
  barkcli calendar [YYYY-MM]    ASCII month calendar

Card operations (board-agnostic; legacy `barkcli <board> <cmd>` also works)
  barkcli add <title>           -d, -p, -l, -a, --column, --due, --effort
  barkcli list                  -c, -p, -l filters
  barkcli show <id>             View task details
  barkcli move <id> <column>    Move task
  barkcli done <id>             Mark as done
  barkcli update <id>           -t, -d, -p, -l, -a, -c, --due
  barkcli remove <id>           Delete task
  barkcli link <id> <target>    --as parent|child|related|blocked-by
  barkcli tree                  Parent → child hierarchy

Management layer
  barkcli intake "<text>"       Classify intent → card + spec
  barkcli plan <card>           Spec + decomposition
  barkcli dispatch              Run orchestration cycle
  barkcli run "<intent>"        Autonomous loop: --agents N, --yes, --offline,
                                --test-cmd, --max-attempts, --dry-run
  barkcli review [--all]        Validate completed work
  barkcli mind sync|show        Project health snapshot
  barkcli skills install|lock|publish   Registry skills pinned in skills.lock
  barkcli memory add|search     Four-tier memory

Pro commands (free, included in MIT)
  barkcli ai "<prompt>"         AI task breakdown
  barkcli report                Weekly report
  barkcli changelog             Release notes
  barkcli stats                 Velocity
  barkcli sync --push/--pull    GitHub sync

Full reference: docs/COMMANDS.md · Online

---

AI Agent Integration

barkcli is an MCP server. Point any MCP-compatible agent at it:

barkcli mcp

Claude Code — add to .claude/settings.json:

{
  "mcpServers": {
    "barkcli": { "command": "barkcli", "args": ["mcp"] }
  }
}

OpenCode — add to .opencode/config.json; Cursor — .cursor/mcp.json, same shape.

The 71 tools cover boards, cards, tasks, agents, memory, specs, sessions, orchestration, code search, and autopilot. Agents can read task context, claim work, update progress, and run cycles — all inside your repo.

• Integration hub
• AI agent setup guide
• AI agent prompt — paste into your coding agent
• MCP agents guide

---

Interfaces

Interface	Command	What it is
CLI	barkcli <cmd>	Full-featured CLI for scripts and automation
Terminal UI	barkcli tui	Ratatui board with vim navigation (tabs for agents/orchestrate)
Web App	barkcli serve --open	Browser UI on :4321 — Mind, Board, Specs, Calendar, Reports, Agents, Memory, Timeline
VS Code	barkcli vscode-install	Custom Editor for .board files
MCP	barkcli mcp	JSON-RPC 2.0 server for AI coding agents
Daemon	barkcli serve --daemon	Background server with live-reload WebSocket

---

Documentation

Guide	What it covers
Autopilot	The intent → approve → merge loop (start here)
Getting Started	Install + first task
Usage manual	Complete how-to guide
Web app guide	Browser interface, tabs, shortcuts, daemon mode
Interfaces	CLI, TUI, web app, VS Code setup
Commands	Full CLI reference
AI agent prompt	Paste into your coding agent
MCP agents	Agent integration via MCP
Code context	Linking cards to code
API reference	REST + WebSocket reference
Advanced	Sessions, checkpoints, sprints, hooks
Live docs	Searchable docs with comparisons

---

Benchmarks & Comparisons

Context benchmark: a cold agent session costs ~29,400 tokens of listing, searching and reading before the first edit on this repo; one read of the auto-maintained project_context.md is ~515. That's 57.1× less context at 339f66a — a deterministic proxy, re-runnable on any repo:

barkcli context benchmark --json

Try it interactively (paste your own output) at akshatnaruka.github.io/barkcli/benchmark.

vs	Read the take
Linear	Repo-native vs cloud-first
Jira	Simple vs enterprise
Trello	Code vs cloud
Notion	Tasks vs everything
GitHub Projects	Local vs platform

The short version: if you want tasks in your repo, offline-ready, with AI agents as first-class workers — barkcli. If you need a mega-platform or enterprise compliance, keep the SaaS tool alongside.

---

Architecture

barkcli/
├── barkcli-core/       # Library: models, storage, commands, memory, agent, autopilot
├── barkcli-cli/        # Binary: pro commands, TUI/serve dispatch, listener
├── barkcli-tui/        # Ratatui terminal board (feature-flagged)
├── barkcli-server/     # Axum web server + WebSocket live reload
├── web/                # React + Vite web frontend
├── vscode-extension/   # VS Code Custom Editor extension
├── landing-next/       # Next.js landing page + docs + llms.txt
└── docs/               # Documentation

Storage model: boards are *.board YAML files (committed); internal metadata lives in .board/ (gitignored, auto-added). Git is the sync layer — push, pull, branch, merge; your board travels with your code.

---

Development

git clone https://github.com/AkshatNaruka/barkcli.git
cd barkcli
cargo build --release
cargo test

For the web app + landing:

cd web && npm install && npm run dev       # web UI (served by `barkcli serve`)
cd landing-next && npm install && npm run build   # marketing + docs site

Contributions welcome — see CONTRIBUTING.

---

Roadmap

• Multi-agent fleet improvements (worktrees, leases, dispatcher v2)
• Skills registry + starter templates (barkcli skills install, templates/)
• Web intent UI + interactive init polish
• WebMCP / OKF agent-readiness layer
• Plugins / hooks ecosystem

Track live work on GitHub Projects — or just barkcli it.

---

Contributing

barkcli is open source (MIT) and welcomes contributions of all kinds — code, docs, design, ideas.

1. Fork the repo.
2. Create a feature branch (git checkout -b feat/amazing).
3. Commit your changes (stem from a board card if you like).
4. Open a pull request.

Full environment setup, project layout, commit conventions, and PR guidelines live in CONTRIBUTING.md — and if you're new, start with a good first issue.

Not ready to code? You can still help: star the repo, report issues, answer discussions, or improve docs.

---

Community

• Docs & Web App: https://akshatnaruka.github.io/barkcli
• Discussions: https://github.com/AkshatNaruka/barkcli/discussions
• Issues: https://github.com/AkshatNaruka/barkcli/issues
• X / Twitter: @probiex007
• Maintainer: Akshat Naruka
• Conduct: read the Code of Conduct before participating
• Security: report vulnerabilities privately via SECURITY.md — never as a public issue

---

License

MIT © 2026 Akshat Naruka. Free to use, modify, and distribute. No cloud, no accounts, no lock-in — every commit is yours.

---

Star History