Aikito

Multi-Agent · Multi-Project · Multi-OS · Multi-Machine

简体中文 · Documentation

Aikito is a Git-managed workspace for governing AI-agent context and durable memory.

   Aikito  =  governing agent resources  ×  curating durable memory

Plain files define the source of truth, explicit scopes define who sees what, and Git keeps the history.

Aikito governs the workspace, agents maintain the memory, and you oversee it all.

One workspace keeps your AI workflow consistent across agents and machines.

Why Aikito

AI agent resources fragment in three directions:

• Across tools: each agent requires a different configuration format
• Across projects: reusable knowledge, skills, and instructions are copied or maintained across multiple repositories
• Across time: valuable decisions and hard-won lessons disappear into old sessions

Aikito keeps all of it in one personal Git workspace and exposes selected resources to each agent and project:

~/aikito
├── skills/                         shared reusable skills
├── memory/                         global durable memory
├── global/                         global instructions
├── mcps/                           shared MCP definitions
├── subagents/                      shared reusable subagents
└── projects/
    └── <project-name>/
        ├── agent.toml              selected shared resources
        ├── AGENTS.md               project instructions
        └── memory/                 project durable memory
            ├── index.md
            └── notes/

No database, daemon, vector store, or hosted service required.

What Aikito Manages

Resource	Canonical source	Synchronized destination
Memory	memory/, projects/<name>/memory/	Global access and <project>/.agents/memory/
Skills	skills/<name>/	Shared and project-level skill directories
Instructions	global/AGENTS.md, projects/<name>/AGENTS.md	Workspace Agent-native instruction paths
MCP servers	mcps/*.toml	Native TOML, JSON, or JSONC configs
Subagents	subagents.toml, subagents/	Native subagent definitions

Project skills can link (stay shared) or copy (isolated snapshot); project memory always uses link.

The default registry includes Codex, Claude Code, Antigravity CLI (agy), OpenCode, GitHub Copilot CLI, DeepSeek Harness (dsh), Grok Build, and Pi. See the architecture for the complete mental model and per-agent capability boundaries.

Durable Memory

The bundled durable-memory skill guides agents to retrieve relevant notes, write durable conclusions, update stale ones, and choose global or project scope. New workspaces enable this by default; nothing is connected to an Agent until you run aikito sync. Notes are ordinary Markdown, so Git history is shared across agents. See default behavior and why memory still needs a maintainer.

aikito show memory lists notes by scope:

┌────────┬───────────────────────┬─────────────────────────────────────┬───────┬──────┐
│ Scope  │ Note File             │ Title                               │ Index │ Link │
├────────┼───────────────────────┼─────────────────────────────────────┼───────┼──────┤
│ Global │ commit-message-style  │ Conventional commits, English only  │ ✓     │ –    │
│ Global │ review-tone           │ Ask before large refactors          │ ✓     │ –    │
├────────┼───────────────────────┼─────────────────────────────────────┼───────┼──────┤
│ aikito │ architecture-decisions│ Stable project design constraints   │ ✓     │ ✓    │
│ aikito │ release-checklist     │ Tag only after tests pass           │ ✓     │ ✓    │
├────────┼───────────────────────┼─────────────────────────────────────┼───────┼──────┤
│ blog   │ draft-workflow        │ Drafts live in content/ until dated │ ✓     │ ✓    │
└────────┴───────────────────────┴─────────────────────────────────────┴───────┴──────┘

Global notes are available everywhere; each project's notes are linked only into that project. In this example, an agent working in aikito sees only the global notes plus aikito's own notes, and nothing from blog.

Use aikito maintain memory for confirmation-gated, full-scope maintenance; see Proactive Scope Maintenance.

Web Console

Browse your workspace, resources, scopes, and governance state in a local, read-only interface:

aikito web

The console binds to 127.0.0.1 and provides a visual view of the canonical workspace without changing its resources.

Boundaries

Aikito manages durable files, explicit scopes, and controlled synchronization. To stay lightweight and portable, it deliberately does not:

• capture every agent action or conversation automatically
• run a vector store, embedding pipeline, or memory service
• inject context into every prompt through a background daemon
• orchestrate supervisor and worker agents
• replace your coding agent's native runtime

Quick Start

Option 1: Let Your Coding Agent Set It Up (Recommended)

Copy this prompt to your coding agent

Install and configure Aikito from https://github.com/lsaint/aikito. Read the README, templates/skills/aikito/SKILL.md, and any linked documentation relevant to the setup, then follow their safety requirements to initialize the workspace, synchronize resources with aikito sync, and verify the result with aikito status. Before importing or changing any existing Agent configuration, show me the planned changes and conflicts and wait for my approval. When setup is complete, summarize what is ready and guide me through the next step, including whether to register my first code project. Do not register a project without my confirmation.

If you use this option, your coding agent performs the installation and setup; you do not need to also follow the manual commands below.

For project registration, resource management, diagnostics, and Memory maintenance prompts, see Agent-first workflows.

Option 2: Set It Up Manually

macOS / Linux — install via Homebrew:

brew install lsaint/tap/aikito

aikito init workspace ~/aikito
aikito sync
aikito status

Installing via Homebrew automatically sets up tab completion for Zsh, Bash, and Fish — no extra configuration needed.

For manual installs (non-Homebrew), add one line to ~/.zshrc:

eval "$(aikito completion zsh)"

Windows — one-liner installer (PowerShell, no admin required):

Prerequisite: Windows Developer Mode must be enabled so that Aikito can create symbolic links. Enable it in Settings → System → For developers → Developer Mode.

irm https://raw.githubusercontent.com/lsaint/aikito/main/install.ps1 | iex

Installer details & custom install directory

The script checks for Python 3.12+, validates Developer Mode, downloads the latest release from GitHub, installs to %LOCALAPPDATA%\Programs\aikito, and adds bin\ to your User PATH automatically.

To customize the install directory:

& ([scriptblock]::Create((irm https://raw.githubusercontent.com/lsaint/aikito/main/install.ps1))) -InstallDir "D:\aikito"

After the installer finishes, open a new terminal and run:

aikito init workspace $env:USERPROFILE\aikito
aikito sync
aikito status

Enable PowerShell tab completion by adding one line to your $PROFILE:

Invoke-Expression (& aikito completion powershell | Out-String)

The workspace is the single Git-managed home for all Aikito resources. You normally initialize one workspace per user or machine.

To connect an existing workspace repository on a new machine:

# Download or clone your workspace repo to ~/aikito
aikito init workspace ~/aikito
aikito sync

Uninstalled Agents and candidate paths on other hosts are recognized as offline on this host without error.

Register each code project that needs project-specific instructions, skills, or memory. From the project directory:

cd ~/code/example
aikito init project

This creates the project's canonical resources under <workspace>/projects/example/ and connects them to ./.agents/. One workspace can manage many projects; a project registration represents one code directory and its project-specific Agent resources, not the project source code itself. Projects support multiple candidate paths ([paths] named tables or paths arrays) for Git worktrees and cross-platform roaming across Mac, Windows, and Linux. Candidate paths missing on the current machine are treated as offline.

When initialized at a custom path, Aikito remembers it for future commands. Use aikito path workspace to print the active path. AIKITO_DIR provides a temporary override, which is useful for CI and isolated automation.

aikito status reports resource state across supported agents:

┌───────────────────────┬──────────────┬────────┬────────────┬───────────┐
│ Agent                 │ Instructions │ Skills │ MCP Config │ Subagents │
├───────────────────────┼──────────────┼────────┼────────────┼───────────┤
│ Codex                 │ ✓            │ 2 ›    │ 0          │ 0         │
│ Claude Code           │ ✓            │ 2 »    │ 0          │ 0         │
│ Antigravity CLI       │ ✓            │ 2 »    │ 0          │ 0         │
│ OpenCode              │ ✓            │ 2 ›    │ 0          │ 0         │
│ GitHub Copilot CLI    │ ✓            │ 2 ›    │ 0          │ 0         │
│ DeepSeek Harness      │ ✓            │ 2 ›    │ 0          │ 0         │
│ Grok Build            │ ✓            │ 2 ›    │ 0          │ 0         │
│ Pi                    │ ✓            │ 2 ›    │ –          │ –         │
└───────────────────────┴──────────────┴────────┴────────────┴───────────┘

✓ all synced · 8 agents · 2 skills · 0 notes across 1 scopes

For building from source, custom install paths, or advanced configuration, see the project setup guide.

Migrating an Existing Setup

If you already use coding agents with existing instructions, MCP definitions, or subagents, import them with aikito adopt:

aikito adopt
aikito adopt --apply

Adoption previews read-only first. Applying creates timestamped backups under ~/.aikito/backups/adopt_<timestamp> and imports detected configurations without overwriting originals. See the safety guide.

Companion: Chat Distiller

Chat Distiller turns browser AI conversations into reviewable Markdown notes and saves them to your Aikito inbox/.

Browser conversation → distilled note → review → durable memory

See capturing browser discussions for the workflow.

Safety First

aikito init workspace creates a local Git repository; it does not make that repository private or safe to publish. Before adding a remote or pushing, review memory and configuration for credentials, customer data, internal addresses, and private code. Deleting a later commit does not remove a secret from Git history.

Read the safety model before synchronizing an existing setup. Report vulnerabilities privately according to the Security Policy.

Documentation

Browse the documentation index for concepts, operational guides, the CLI reference, safety details, the roadmap, and the FAQ. Comparison places Aikito alongside memory systems, project-local sync tools, and agent orchestrators.

Support

If you find Aikito useful, you can support its development.