• Go 1.26.2 or newer

Since CAM is distributed from source, build and install the Go binaries locally:

# Clone the repository
git clone https://github.com/Chat2AnyLLM/code-agent-manager.git
cd code-agent-manager

# Run the install script
./install.sh

# Install using the install script directly
./install.sh

# Or install from the web
curl -fsSL https://raw.githubusercontent.com/Chat2AnyLLM/code-agent-manager/main/install.sh | bash

# Install from source directly
git clone https://github.com/Chat2AnyLLM/code-agent-manager.git
cd code-agent-manager
go test ./...
go build -o dist/cam ./cmd/cam

1. Create your base config files:

   mkdir -p ~/.config/code-agent-manager
   touch ~/.env
   chmod 600 ~/.env

2. Set up your API keys in .env:

   export ANTHROPIC_API_KEY="your-anthropic-key"
   export GITHUB_TOKEN="your-github-token"
   export GEMINI_API_KEY="your-gemini-key"

3. Source the environment file and verify setup:

   source ~/.env
   cam doctor

4. Launch the interactive menu:

   cam launch

5. Select your assistant and start coding!

CAM now uses a Tauri desktop shell with a Go sidecar API. The same Go backend packages power both the terminal CLI and the desktop UI, so provider and launch behavior stays consistent across interfaces.

Use make start from the repository root:

make start

make start, make app, and make dev all run the same full desktop startup path. They build the Go sidecar expected by Tauri, start the Vite frontend dev server through Tauri, and open the desktop window.

Use this when you only want the React UI in a browser with mock/fallback data or a manually configured sidecar URL:

make frontend

The browser frontend listens on http://127.0.0.1:5173 by default. Override the host or port when needed:

make frontend FRONTEND_HOST=127.0.0.1 FRONTEND_PORT=5174

Use this for API testing without opening the desktop window:

make sidecar

By default, the sidecar binds to 127.0.0.1 and chooses a random port (SIDECAR_PORT=0). It prints startup JSON containing the selected port and bearer token. Override values when needed:

make sidecar SIDECAR_PORT=54321

make desktop-build

This runs the frontend production build, builds the Go sidecar, and checks the Tauri shell with Cargo. On Windows, the Makefile sets CARGO_HTTP_CHECK_REVOKE=false to avoid certificate revocation-check failures when Cargo downloads crates.

make start  # start the full Tauri desktop app
make build   # build CLI binaries and sidecar into dist/
make test    # run Go tests
make check   # run Go vet, Go tests, frontend tests/build, sidecar build, and cargo check
make clean   # remove generated build outputs

CAM uses these main configuration files:

• ~/.config/code-agent-manager/cam.db: SQLite app state database that stores providers and other state.
• ~/.env: API keys and sensitive environment variables.
• ~/.config/code-agent-manager/config.yaml: repository-source config for instructions, skills, agents, plugins, and MCP server catalogs.

• CAM loads ~/.config/code-agent-manager/config.yaml first; if missing, it falls back to the bundled Go config at internal/camconfig/embed/config.yaml.
• The file defines source lists for instructions, skills, agents, plugins, and mcpServers.
• Local JSON sources (instruction_repos.json, skill_repos.json, agent_repos.json, plugin_repos.json) are loaded first.
• Remote sources are merged after local sources and do not override existing local keys.
• Remote responses are cached in ~/.cache/code-agent-manager/repos (TTL controlled by config.yaml).
• Prompt and MCP catalog sources default to their upstream config.yaml files; CAM reads the sources: entries and fetches the configured upstream files directly instead of consuming generated dist/*.json artifacts.

In the era of AI-driven development, developers often use multiple powerful assistants like Claude, GitHub Copilot, and Gemini. However, this leads to a fragmented and inefficient workflow:

• Scattered Configurations: Each tool has its own setup, API keys, and configuration files.
• Inconsistent Behavior: System prompts and custom instructions diverge, leading to different AI behaviors across projects.
• Wasted Time: Constantly switching between different CLIs and UIs is a drain on productivity.

CAM solves this by providing a single, consistent interface to manage everything, turning a chaotic toolkit into a cohesive and powerful development partner.

• Unified Management: One tool (cam) to install, configure, and run all your AI assistants
• Centralized Configuration: Manage API keys with environment variables in .env and persist provider settings in CAM's SQLite app state
• Interactive TUI: A polished, interactive menu (cam launch) for easy navigation and operation with arrow-key navigation
• MCP Catalog Registry: Source-backed catalog with 381+ pre-configured MCP servers ready to install across all supported tools
• Extensible Framework: Standardized architecture for managing agents, instructions, skills, and plugins

CAM supports 17 AI coding assistants:

Manage standalone assistant configurations with markdown-based definitions and YAML front matter.

Managed coding-agent instruction files such as CLAUDE.md, AGENTS.md, GEMINI.md, and Copilot instruction files, installable at user or project scope where supported.

Custom tools and functionalities for your agents (directory-based with SKILL.md).

Marketplace extensions for supported assistants (GitHub repos or local paths).

Note: non-boolean CLI options are long-form only. For example, use --config and --scope (not -c or -s).

Upgrade one tool, selected tools in order, or every enabled tool:

cam upgrade codex
cam upgrade codex,claude
cam upgrade all

CAM is governed by a speckit-driven development framework ensuring consistent, high-quality evolution with:

• Constitutional Principles: Unified interface, security-first design, TDD practices, extensible architecture, quality assurance
• Enterprise Security: Config-first approach eliminates shell injection vulnerabilities
• Comprehensive Testing: Enterprise-grade test suite with 1,423+ tests
• Automated Quality Assurance: Built-in complexity monitoring, file size limits, and CI/CD quality gates

• Discord: Join our community for discussions and support
• GitHub Issues: Report bugs and request features
• Contributing: See our Contributing Guidelines

This project is licensed under the MIT License.