Automatic
Manage and sync your skills, MCP servers, rules, hooks, and project instructions. Works with Claude Code, Codex, Cursor, and 13 other agent tools.
Automatic is a desktop hub for managing AI agent configuration across projects. It gives you one place to organise the skills, MCP servers, rules, hooks, templates, and project settings that power your agents, then syncs that configuration into the tools you actually use.
The goal is simple: capture the patterns that work once, reuse them everywhere, and stop rebuilding agent context from scratch for every new project.
Why Automatic
- Keep project instructions, rules, skills, and MCP servers in one place
- Sync configuration into agent tools instead of maintaining each tool manually
- Detect drift when a project no longer matches the saved configuration
- Reuse proven setups through templates and cloned projects
- Browse and install skills and MCP servers from curated marketplaces
- Expose an MCP server so agents can pull skills, memory, and project configuration directly from Automatic
- Store and retrieve project memory across sessions so agents retain context over time
Who It Is For
Automatic is for teams and individuals who use agent tools heavily and want consistent context across projects.
It is especially useful if you:
- switch between Claude Code, Codex, Cursor, and other tools
- maintain the same MCP servers or instructions in multiple places
- want reusable project templates for common workflows
- need agents to read shared memory, skills, or project configuration over MCP
- want a feature board that agents can read and update as they work
How It Works
Automatic is a hub, not an executor.
It does not run agents for you. Instead, it stores and organises the configuration your agents need:
- Define skills, MCP servers, rules, templates, and project instructions in Automatic.
- Assign those resources to a project.
- Sync that project into supported agent tools.
- Let agents connect to Automatic's MCP server to read project context, skills, and memory.
That separation matters because it keeps your configuration portable. Your agents can change. Your context stays consistent.
Install
Automatic runs on macOS, Windows, and Linux.
After installing:
- Open Automatic.
- Configure your agent tools and projects.
- Add the skills, rules, MCP servers, and templates you want to reuse.
- Sync the project configuration into your local agent setup.
Quick Start
- Install and open Automatic.
- Create or import a project.
- Add the skills, rules, and MCP servers that project needs.
- Sync the project to your agent tool.
- Use the marketplaces to import additional skills, MCP servers, or templates.
- Let connected agents pull project context and memory from Automatic over MCP.
Core Features
Projects
Each project in Automatic maps to a directory on disk and brings together all the configuration an agent needs:
- Instructions — project-level instruction files that guide agent behaviour
- Rules — code style, review checklists, debugging methodology, and other behavioural constraints
- Skills — reusable prompt-based capabilities assigned to the project (global or project-local custom skills)
- MCP Servers — Model Context Protocol servers the project depends on
- Agents — which agent tools (Claude Code, Cursor, Codex, etc.) are enabled for the project
- Sub-agents — specialised agent configurations for specific tasks
- Commands — custom commands scoped to the project
- Hooks — lifecycle scripts synced per agent, either inline or referencing an existing script file
- Context — auto-generated project snapshot (directory tree, config files, key documentation) for AI consumption
- Documentation — links to external docs relevant to the project
- Plugins — extend project capabilities with additional integrations
Projects can be organised into groups for related codebases, cloned as starting points for new work, and synced into agent tools with one click.
Library
The library is a global registry of reusable resources that can be assigned to any project:
- Templates — groups of instructions bundled together for common scenarios
- Instructions — standalone instruction files for agent guidance
- Rules — reusable rules for code quality, security, review, and more
- Sub-Agents — pre-configured agent roles for specialised tasks
- Commands — reusable command definitions
- Hooks — reusable lifecycle scripts that templates can bundle and projects sync per agent
- Skills — prompt-based capabilities (21 bundled skills covering code review, testing, debugging, security, performance, documentation, refactoring, API design, database design, and framework-specific guidance for Laravel, PHP, Python, Terraform, Tailwind CSS, React/Next.js)
- MCP Servers — Model Context Protocol server configurations
- Providers — supported agent tools and their sync settings
- Tools — available tool integrations
Skills can be installed from the marketplace, created locally, or scoped to individual projects. They are synced to agent tool directories as symlinks or copies (configurable), and remote-sourced skills check for upstream updates with an in-app "Update now" action.
Library items — skills, commands, rules, and sub-agents — can also be drafted with the AI-powered Library Generator instead of being written by hand.
Marketplace
Browse, search, and install community resources:
- Collections — curated bundles of skills, MCP servers, and templates grouped by workflow or domain
- Templates — pre-built project configurations ready to import
- Skills — community skills from the skills.sh registry
- MCP Servers — a curated directory of Model Context Protocol servers
Project Sync
- Sync configuration into 17 supported agent tools with one click
- Auto-detect installed agents and import their existing MCP server configs
- Detect configuration drift when on-disk files diverge from saved state
- Rebuild or recover configuration when drift is detected
- Apply templates to projects to quickly set up a standard configuration
MCP Service
Automatic exposes a full MCP server (over stdio) with 41 tools that agents can call directly:
| Category | Tools |
|---|
| Projects | List, read, sync projects; get project context; discover related projects via groups |
| Skills | List, read, search skills (global and project-local) |
| Memory | Store, get, list, search, delete, clear memory entries; read Claude Code auto-memory files |
| Features | Create, list, get, update, archive, unarchive, delete features; set lifecycle state; add progress updates |
| Rules | Create, read, update, delete, list rules; attach and detach them from projects |
| Hooks | Create, read, update, delete, list hooks; attach and detach them from projects |
| Credentials | Retrieve API keys for LLM providers (Anthropic, OpenAI, Gemini, and others) |
| MCP Servers | List registered MCP server configurations |
| Sessions | List active Claude Code sessions tracked by Automatic |
Run the MCP server standalone with automatic mcp-serve or let the desktop app serve it automatically.
Feature Tracking
- Built-in Kanban-style feature board with states: backlog, todo, in progress, review, complete, cancelled
- Agents can create, update, and progress features through MCP tools as they work
- Priority levels, effort estimates, assignees, tags, and linked files per feature
- Append progress updates to features for a running log of decisions and blockers
- Archive and restore features to keep the board clean
Memory System
- Project-scoped key-value store that persists across sessions
- Agents store architectural decisions, conventions, gotchas, and setup notes
- Full-text search across keys and values
- Integrates with Claude Code's auto-memory (MEMORY.md) for seamless context sharing
Credentials and Security
- Store LLM provider API keys securely in the system keychain
- OAuth 2.0 flow support for MCP server authentication
- Encrypted environment variable storage (AES-GCM)
- Agents retrieve credentials via MCP without exposing raw keys
Command Line Interface
The bundled automatic CLI ships as a fourth mode of the desktop binary, alongside the GUI, the MCP stdio server, and the MCP proxy. Install it with one click from Settings → Command Line (macOS, Windows, and Linux).
- Verbs cover projects, skills, MCP servers, memory, and rules
- Every command supports
--json (returning the same shapes as the MCP tools), plus --quiet and standard exit codes
automatic init <template> writes the files a project sync would write into a target directory without registering a project
Utilities
- Token Estimator — estimate token counts for messages before sending them to an LLM
- AI Playground — run prompts against a live model list with library read and marketplace search tools available to the built-in agent
- Insights — AI-powered recommendations for skills, MCP servers, and agents per project
Supported Agent Tools
Automatic syncs configuration into 18 agent tools. The matrix below reflects what each tool's configuration format actually supports — ✓ means Automatic writes that surface, — means the tool does not expose it (or manages it through a separate global config Automatic does not own).
| Tool | Skills | Project instructions | MCP servers | Sub-agents | Commands |
|---|
| Claude Code | ✓ | ✓ | ✓ | ✓ | ✓ |
| Gemini CLI | ✓ | ✓ | ✓ | ✓ | ✓ |
| OpenCode | ✓ | ✓ | ✓ | ✓ | ✓ |
| GitHub Copilot | ✓ | ✓ | ✓ | — | ✓ |
| Codex CLI | ✓ | ✓ | ✓ | ✓ | — |
| Cursor | ✓ | ✓ | ✓ | ✓ | — |
| Kimi Code | ✓ | ✓ | ✓ | ✓ | — |
| Zed | ✓ | ✓ | ✓ | ✓ | — |
| Pi | ✓ | ✓ | ✓ | ✓ | — |
| Droid | ✓ | ✓ | ✓ | — | — |
| Junie | ✓ | ✓ | ✓ | — | — |
| Kilo Code | ✓ | ✓ | ✓ | — | — |
| Kiro | ✓ | ✓ | ✓ | — | — |
| Z Code | ✓ | ✓ | ✓ | — | — |
| Antigravity | ✓ | ✓ | — | — | — |
| Cline | ✓ | ✓ | — | — | — |
| Goose | ✓ | ✓ | — | — | — |
| Warp | ✓ | ✓ | — | — | — |
Notes:
- Rules are injected into each tool's project-instructions file (
CLAUDE.md, AGENTS.md, .cursorrules, etc.), so rules support follows the "Project instructions" column.
- Antigravity, Cline, Goose, and Warp manage MCP servers through their own global app/CLI config rather than a project file. Automatic can discover those servers but does not write project-level MCP config for them.
- Pi reads MCP servers and sub-agents through the
pi-mcp-adapter and pi-subagents community extensions. Automatic writes a Pi-scoped .pi/mcp.json (kept separate from Claude Code's .mcp.json) and .pi/agents/, and shares AGENTS.md rather than owning it.
- Z Code merges MCP servers into the shared
.zcode/config.json, preserving the user's other keys. Z Code ignores project-level hooks for security (only user-level ~/.zcode/cli/config.json hooks execute), and its workspace-level command and sub-agent paths are undocumented, so Automatic does not sync those surfaces.
- Automatic auto-detects installed tools and writes to their config directories.
Privacy and Security
Automatic stores and manages local agent configuration on your machine.
- All configuration is file-based and stored locally (no external database)
- OAuth tokens and API keys are stored in the platform-native keychain
- Sensitive environment variables are encrypted at rest with AES-GCM
- Analytics are opt-in only and can be disabled at any time
If you are evaluating Automatic for a team, review the app configuration and MCP server setup for your environment before rolling it out broadly.
Development
This repository contains the Automatic desktop app built with Tauri 2, Rust, React 19, and TypeScript.
Prerequisites
- Node.js
- Rust toolchain
- Tauri 2 build prerequisites for your platform
Run Locally
npm install
npm run tauri dev
Build
make build # Full Tauri production build
npm run build # Frontend only
Check and Test
make check # Frontend type check + Rust clippy
cargo test # Rust unit tests (from src-tauri/)
npm run lint # TypeScript type checking
Architecture
The desktop app has two main parts:
- A React + TypeScript frontend for managing projects, skills, templates, marketplaces, and settings
- A Rust backend (Tauri 2) that handles business logic, local configuration, syncing, and the MCP server
The application runs in four modes, all dispatched from the same binary:
- Desktop GUI (default) — full UI for managing configuration
- MCP server (
mcp-serve) — standalone stdio-based MCP server exposing 41 tools
- MCP proxy (
mcp-proxy) — transparent proxy with keychain-based authentication
- CLI (any CLI verb) — scriptable command surface for projects, skills, MCP servers, memory, and rules
Key source locations:
src/App.tsx — Shell and tab-based navigationsrc-tauri/src/core/ — Business logic (skills, projects, MCP servers, rules, templates, commands, marketplace)src-tauri/src/mcp.rs — MCP server implementation (rmcp SDK)src-tauri/src/sync/ — Sync engine with drift detectionsrc-tauri/src/memory.rs — Key-value memory storagesrc-tauri/src/context.rs — AI context generationsrc-tauri/src/agent/ — Agent tool integrations (17 providers)
License
Automatic is released under the Business Source License 1.1.
- Free use: Internal business use with up to 10 concurrent users
- Commercial license required: For use beyond 10 users, distribution, resale, or SaaS deployment
- Attribution required: Forks must attribute the original Licensor
- Time-delayed open source: Converts to MIT License on March 23, 2030
See LICENSE for full terms
Links
