Matir's Notebook

Agent Configs

14 min read

AI Agent Configuration Comparison

This document provides a detailed breakdown and comparison of configuration paths across major AI coding agent platforms: Claude Code, OpenAI Codex, Google Antigravity, Google Antigravity CLI, OpenCode, Kilo Code, Cursor, GitHub Copilot, and Aider.

NOTE

Google Antigravity vs. Antigravity CLI: Both surfaces run on the same shared underlying agent harness and customization engine. They share identical public paths for Main Context Files (AGENTS.md), MCP Server definitions (mcp_config.json), and Agent Skills (skills/). However, the CLI maintains separate surface-level settings at ~/.gemini/antigravity-cli/settings.json.

The comparison is organized across seven core functional dimensions:

  1. Main Context File (instruction manuals and rule briefs like AGENTS.md or CLAUDE.md)
  2. MCP Servers (Model Context Protocol configuration files)
  3. Agent Skills (reusable capabilities and workflows)
  4. Execution Hooks (pre/post tool execution handlers and lifecycle scripts)
  5. Custom Subagents & Modes (specialized agent definitions and mode paths)
  6. File Access & Ignore Controls (workspace exclusion files like .antigravityignore or .claudeignore)
  7. Plugin & Extension Bundling (packaged deployment units containing plugin.json)

1. Main Context File

Overview

The Main Context File provides persistent instructions, rules, coding guidelines, and project architecture overviews to the AI agent. Rather than needing to repeat instructions in every prompt, agents automatically load these Markdown files at startup to ground their reasoning and tool usage.

Configuration Matrix

Platform / AgentUser-Level Config PathPer-Project Config PathMulti-Path / Hierarchical Search
Claude Code~/.claude/CLAUDE.md./CLAUDE.md
./.claude/CLAUDE.md		Yes: Traverses from working directory up to git/project root, combining with global user rules.
OpenAI Codex~/.codex/AGENTS.md./AGENTS.md
./.codex/AGENTS.md		Yes: Scans directory tree; nested/closer directory files take precedence over parent or global files.
Google Antigravity~/.gemini/config/AGENTS.md./AGENTS.md
./.agents/AGENTS.md		Yes: Performs parent traversal from current file folder to workspace root, loading all AGENTS.md files.
Google Antigravity CLI~/.gemini/config/AGENTS.md./AGENTS.md
./.agents/AGENTS.md		Yes: Uses identical parent directory traversal and scoped rule aggregation as Antigravity Desktop/IDE.
OpenCode~/.config/opencode/AGENTS.md./AGENTS.md
./.opencode/AGENTS.md		Yes: Evaluates global and project-level files in priority hierarchy (Project > Global > Remote).
Kilo Code~/.config/kilo/AGENTS.md./AGENTS.md
./.kilocode/AGENTS.md		Yes: Supports nested AGENTS.md files in subdirectories, overriding parent or global rules.
Cursor~/.cursor/rules/./AGENTS.md
./.cursorrules
./.cursor/rules/*.mdc		Yes: Evaluates workspace root rules, glob-matched .mdc rules, and global user rules.
GitHub Copilot~/.config/github-copilot/instructions.md./AGENTS.md
./.github/copilot-instructions.md
./.github/instructions/*.md		Yes: Combines repository instructions with subfolder-scoped .github/instructions/*.md files.
Aider~/.aider.conf.yml./AGENTS.md
./CONVENTIONS.md
./.aider.conventions.md		Yes: Reads global config defaults, workspace conventions files, and git repository rules.

2. MCP Servers

Overview

The Model Context Protocol (MCP) is an open standard that allows AI agents to securely connect to external tools, databases, documentation servers, and third-party APIs. MCP configuration files define server executables, transport mechanisms (stdio, SSE, or streamable HTTP), and environment variables.

Configuration Matrix

Platform / AgentUser-Level Config PathPer-Project Config PathMulti-Path / Hierarchical Search
Claude Code~/.claude.json./.mcp.jsonYes: Merges global servers in ~/.claude.json with project-specific servers in .mcp.json.
OpenAI Codex~/.codex/config.toml./.codex/config.toml
./.codex/mcp.json		Yes: Aggregates global configuration entries with project-level settings.
Google Antigravity~/.gemini/config/mcp_config.json./.agents/mcp_config.jsonYes: Aggregates server definitions across global user configs, workspace paths, and active plugins.
Google Antigravity CLI~/.gemini/config/mcp_config.json./.agents/mcp_config.jsonYes: Shares the core MCP engine and discovery logic with Antigravity Desktop/IDE.
OpenCode~/.config/opencode/opencode.json./opencode.json
./.opencode/opencode.json		Yes: Merges global opencode.json settings with per-project configurations.
Kilo Code~/.config/kilo/kilo.jsonc./kilo.jsonc
./.kilo/kilo.jsonc		Yes: Merges user-level kilo.jsonc configurations with project-level config files.
Cursor~/.cursor/mcp.json./.cursor/mcp.jsonYes: Merges global Cursor MCP configuration with workspace .cursor/mcp.json.
GitHub Copilot~/.config/github-copilot/mcp.json./.github/mcp.jsonYes: Combines global Copilot tool integrations with workspace .github/mcp.json.
Aider~/.aider.conf.yml./.aider.conf.ymlYes: Merges mcp-servers settings defined in global and local .aider.conf.yml files.

MCP Format Examples & Compatibility

Format 1: Standard mcpServers JSON Object

The standard format defined by the core Model Context Protocol ecosystem.

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    },
    "remote-service": {
      "url": "https://mcp.example.com/sse",
      "headers": {
        "Authorization": "Bearer token123"
      }
    }
  }
}
  • Compatible Platforms: Claude Code, Google Antigravity, Google Antigravity CLI, Kilo Code, and OpenCode (via fallback parser).

Format 2: OpenCode Custom JSON Object (mcp)

Uses an "mcp" key with explicit type declarations ("local" vs "remote") and command arrays.

{
  "mcp": {
    "github": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-github"],
      "environment": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    },
    "remote-service": {
      "type": "remote",
      "url": "https://mcp.example.com/sse"
    }
  }
}
  • Compatible Platforms: OpenCode (opencode.json).

Format 3: OpenAI Codex TOML Configuration

Defines servers using TOML table syntax ([mcp_servers.<name>]).

[mcp_servers.github]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-github"]
env = { GITHUB_PERSONAL_ACCESS_TOKEN = "ghp_xxx" }
 
[mcp_servers.remote-service]
url = "https://mcp.example.com/sse"
  • Compatible Platforms: OpenAI Codex (config.toml).

3. Agent Skills

Overview

Agent Skills are directory-based capability packages containing a SKILL.md manifest (with metadata and instructions) alongside supporting scripts, documentation references, or assets. Skills operate on a progressive disclosure model: agents load only skill names and descriptions into primary context, retrieving full instructions and scripts only when relevant to a specific user prompt.

Configuration Matrix

Platform / AgentUser-Level Config PathPer-Project Config PathMulti-Path / Hierarchical Search
Claude Code~/.claude/skills/./.claude/skills/Yes: Discovers skills from both global (~/.claude/skills/) and project (.claude/skills/) directories.
OpenAI Codex~/.codex/skills/./.codex/skills/
./skills/		Yes: Discovers installed skills from both user home directories and local repository paths.
Google Antigravity~/.gemini/config/skills/./.agents/skills/Yes: Collects skills across user home directories, workspace folders (and parent traversals), and loaded plugins.
Google Antigravity CLI~/.gemini/config/skills/./.agents/skills/Yes: Shares skill resolution and progressive disclosure pipeline with Antigravity Desktop/IDE.
OpenCode~/.config/opencode/skills/./.opencode/skills/Yes: Automatically indexes skills from global user folders and local workspace directories.
Kilo Code~/.kilocode/skills/./.kilocode/skills/Yes: Scans global and project-level skill folders, dynamically serving instructions based on intent.
Cursor~/.cursor/skills/./.cursor/rules/
./.cursor/skills/		Yes: Discovers workspace rules and tool definitions in .cursor/.
GitHub Copilot~/.config/github-copilot/skills/./.github/skills/Yes: Discovers repository skills and extension capabilities.
Aider~/.aider/skills/./.aider/skills/Yes: Discovers python helper utilities and custom command scripts.

4. Execution Hooks

Overview

Execution Hooks are event-driven handlers that automatically execute scripts or commands during specific stages of the agent’s interaction lifecycle (such as before running shell commands, after editing files, upon receiving user input, or prior to tool invocation).

Configuration Matrix

Platform / AgentUser-Level Config PathPer-Project Config PathMulti-Path / Hierarchical Search
Claude Code~/.claude/hooks.json./.claude/hooks.jsonYes: Merges user-level and project-level hook definitions.
OpenAI Codex~/.codex/config.toml./.codex/config.tomlYes: Aggregates [hooks] definitions in global and local configuration files.
Google Antigravity~/.gemini/config/hooks.json./.agents/hooks.jsonYes: Discovers hook definitions across user home directories, workspace parent traversals, and active plugins.
Google Antigravity CLI~/.gemini/config/hooks.json./.agents/hooks.jsonYes: Shares hook resolution and event trigger pipelines with Antigravity Desktop/IDE.
OpenCode~/.config/opencode/opencode.json./opencode.json
./.opencode/opencode.json		Yes: Combines lifecycle event listeners configured in global and local opencode.json files.
Kilo Code~/.config/kilo/kilo.jsonc./kilo.jsonc
./.kilo/kilo.jsonc		Yes: Combines global and workspace-level hook configurations.
Cursor~/.cursor/hooks.json./.cursor/hooks.jsonYes: Merges global Cursor hooks with project-level .cursor/hooks.json.
GitHub Copilot~/.config/github-copilot/hooks.json./.github/hooks.jsonYes: Triggers pre/post tool hooks configured in global and workspace settings.
Aider~/.aider.conf.yml./.aider.conf.ymlYes: Executes configured lint-cmd and test-cmd hooks post-edit.

5. Custom Subagents & Modes

Overview

Custom Subagents and Modes allow developers to define specialized secondary assistants with targeted prompt instructions, scoped tool allowances, and restricted file execution permissions (such as dedicated code-reviewer, security auditor, architect, or planning agents).

Configuration Matrix

Platform / AgentUser-Level Config PathPer-Project Config PathMulti-Path / Hierarchical Search
Claude Code~/.claude/skills/./.claude/skills/Yes: Invokes specialized skill routines on demand via /skill-name or prompt matching.
OpenAI Codex~/.codex/agents/./.codex/agents/Yes: Discovers custom subagent definitions across global and project paths.
Google Antigravity~/.gemini/config/agents/./.agents/agents/Yes: Aggregates subagent definitions across user home directories, workspace parent traversals, and loaded plugins.
Google Antigravity CLI~/.gemini/config/agents/./.agents/agents/Yes: Shares subagent discovery and invocation engines with Antigravity Desktop/IDE.
OpenCode~/.config/opencode/agents/./.opencode/agents/Yes: Indexes custom primary and subagent Markdown definitions across global and project paths.
Kilo Code~/.config/kilo/modes/./.kilocode/modes/Yes: Configures custom mode routines (e.g., Code, Architect, Ask) in global or project paths.
Cursor~/.cursor/agents/./.cursor/agents/Yes: Supports custom agent prompts and subagent routines in .cursor/.
GitHub Copilot~/.config/github-copilot/agents/./.github/agents/Yes: Supports custom agent participants and Copilot extensions.
AiderN/A./.aider.conf.ymlYes: Toggles dual-agent pairing modes (Architect vs. Editor) via .aider.conf.yml.

6. File Access & Ignore Controls

Overview

File Access and Ignore Controls define workspace exclusion rules and sandboxing guardrails using glob patterns (similar to .gitignore) to prevent AI agents from accessing, indexing, or modifying sensitive files, credentials, dependency directories, or build outputs.

Configuration Matrix

Platform / AgentUser-Level Config PathPer-Project Config PathMulti-Path / Hierarchical Search
Claude Code~/.claude/settings.json./.claudeignoreYes: Checks .claudeignore at workspace root and respects .gitignore rules.
OpenAI Codex~/.codex/config.toml./.codexignoreYes: Evaluates [security.ignore] settings in config.toml alongside workspace .codexignore rules.
Google AntigravityN/A./.antigravityignoreYes: Enforces workspace .antigravityignore patterns and automatically respects standard .gitignore rules.
Google Antigravity CLIN/A./.antigravityignoreYes: Shares file sandboxing and exclusion guardrails with Antigravity Desktop/IDE.
OpenCode~/.config/opencode/opencode.json./.opencodeignoreYes: Merges global ignore configurations in opencode.json with workspace .opencodeignore rules.
Kilo Code~/.config/kilo/kilo.jsonc./.kilocodeignoreYes: Enforces path-level permission rules defined in .kilocodeignore and kilo.jsonc.
CursorN/A./.cursorignoreYes: Filters files using .cursorignore patterns and respects workspace .gitignore.
GitHub CopilotN/A./.copilotignoreYes: Excludes patterns in .copilotignore and respects workspace .gitignore.
AiderN/A./.aiderignoreYes: Filters files using .aiderignore patterns and respects standard .gitignore.

7. Plugin & Extension Bundling

Overview

Plugin and Extension Bundling allows teams to package and distribute rules, MCP servers, hooks, skills, and subagents into single, version-controlled deployment units that can be shared across teams or installed via marketplaces.

Configuration Matrix

Platform / AgentUser-Level Config PathPer-Project Config PathMulti-Path / Hierarchical Search
Claude Code~/.claude/plugins/./.claude/plugins/Yes: Scans user-installed plugin packages and workspace plugin folders.
OpenAI Codex~/.codex/plugins/./.codex/plugins/Yes: Indexes user-level installed extensions and repository plugin manifests.
Google Antigravity~/.gemini/antigravity-cli/plugins/./.agents/plugins/Yes: Discovers namespaced plugin bundles containing plugin.json, mcp_config.json, hooks.json, skills/, agents/, and rules/.
Google Antigravity CLI~/.gemini/antigravity-cli/plugins/./.agents/plugins/Yes: Shares plugin discovery and module loading pipelines with Antigravity Desktop/IDE.
OpenCode~/.config/opencode/plugins/./.opencode/plugins/Yes: Loads installed global plugins and project-level plugin folders.
Kilo Code~/.kilocode/plugins/./.kilocode/plugins/Yes: Loads extensions installed from the Kilo Marketplace or specified in project settings.
Cursor~/.cursor/extensions/./.cursor/plugins/Yes: Discovers installed extensions and workspace plugin bundles.
GitHub CopilotCopilot Extensions Marketplace./.github/plugins/Yes: Integrates GitHub Copilot App extensions and repository plugins.
Aider~/.aider/plugins/./.aider/plugins/Yes: Discovers installed python extensions and custom scripts.

Plugin Directory Structures & Manifest Formats

While all agent plugin architectures aim to encapsulate capabilities (instructions, tools, hooks, and subagents), different platforms utilize distinct directory layouts and manifest schemas.

1. Google Antigravity & Antigravity CLI Plugin Structure

Google Antigravity plugins are self-contained, namespaced directory bundles discovered from user-level (~/.gemini/antigravity-cli/plugins/) or project-level (./.agents/plugins/) paths. A root plugin.json serves as the manifest declaring plugin metadata and entrypoint pointers.

<plugin-name>/
├── plugin.json              # Primary manifest defining metadata and component entrypoints
├── mcp_config.json          # Bundled MCP server definitions
├── hooks.json               # Event hooks (pre/post execution handlers)
├── AGENTS.md                # Scoped context rules injected when plugin is active
├── skills/                  # Progressive disclosure skill directories
│   └── <skill-name>/
│       ├── SKILL.md         # Skill instructions & metadata
│       └── scripts/         # Supporting execution scripts or binaries
├── agents/                  # Specialized subagent definitions (.md)
│   └── code-reviewer.md
└── rules/                   # Modular domain guidelines & coding standards
    └── api-guidelines.md
Manifest Schema (plugin.json):
{
  "name": "enterprise-workflow-pack",
  "version": "1.0.0",
  "description": "Enterprise CI/CD tools, MCP servers, and reviewer subagents",
  "manifestVersion": 1,
  "entrypoints": {
    "mcpConfig": "./mcp_config.json",
    "hooks": "./hooks.json",
    "instructions": "./AGENTS.md",
    "skills": "./skills/",
    "agents": "./agents/",
    "rules": "./rules/"
  }
}

2. Claude Code Plugin Structure

Claude Code plugins package reusable tool integrations, MCP servers, lifecycle hooks, and progressive disclosure skills. The plugin manifest points to MCP configurations and skill directories.

<plugin-name>/
├── plugin.json              # Claude Code plugin manifest
├── .mcp.json                # Bundled MCP server configurations
├── hooks.json               # Lifecycle command hooks
├── CLAUDE.md                # Scoped plugin instructions and rules
└── skills/                  # Capability skill directories
    └── security-scanner/
        └── SKILL.md         # Skill definition and instructions
Manifest Schema (plugin.json):
{
  "name": "claude-security-pack",
  "version": "1.0.0",
  "description": "Security auditing tools, hooks, and scanning skills",
  "mcpServers": "./.mcp.json",
  "hooks": "./hooks.json",
  "skillsDirectory": "./skills",
  "rulesFile": "./CLAUDE.md"
}

3. OpenAI Codex Plugin Structure

OpenAI Codex extensions use a codex-plugin.toml (or plugin.json) descriptor alongside a standard config.toml to register bundled subagents, hooks, and MCP servers.

<plugin-name>/
├── codex-plugin.toml        # Plugin descriptor and capability exports
├── config.toml              # Bundled MCP servers ([mcp_servers]) and hooks ([hooks])
├── agents/                  # Subagent prompt and tool definitions (.toml or .md)
│   └── architect.toml
└── skills/                  # Progressive disclosure skill folders
    └── db-migrate/
        └── SKILL.md
Manifest Schema (codex-plugin.toml):
[plugin]
name = "codex-cloud-pack"
version = "1.0.0"
description = "Cloud architecture subagents and database migration skills"
 
[components]
config = "./config.toml"
agents = "./agents"
skills = "./skills"

4. OpenCode Plugin Structure

OpenCode plugins encapsulate custom tools, subagents, and MCP configurations, declared via a root plugin.json referencing an opencode.json configuration file.

<plugin-name>/
├── plugin.json              # OpenCode plugin metadata and entrypoint mappings
├── opencode.json            # MCP server declarations ("mcp" key) and hook listeners
├── agents/                  # Custom primary and subagent Markdown definitions
│   └── test-runner.md
└── skills/                  # OpenCode skill packages
    └── unit-test-gen/
        └── SKILL.md
Manifest Schema (plugin.json):
{
  "name": "opencode-testing-suite",
  "version": "1.0.0",
  "description": "Automated unit test generation skills and test runner subagents",
  "config": "./opencode.json",
  "skills": "./skills",
  "agents": "./agents"
}

5. Cursor Extension / Plugin Structure

Cursor plugins and extensions package glob-targeted .mdc rules, MCP server definitions, and custom subagent participant prompts into installable packages defined by package.json or extension.json.

<extension-name>/
├── package.json             # Extension manifest and Cursor contribution points
├── mcp.json                 # Bundled MCP server configurations
├── rules/                   # Glob-targeted rule files (.mdc)
│   └── react-patterns.mdc
└── agents/                  # Custom agent prompts and participant configurations
    └── ui-designer.md
Manifest Schema (package.json):
{
  "name": "cursor-react-toolkit",
  "version": "1.0.0",
  "description": "React development rules, MCP tools, and custom subagents for Cursor",
  "cursor": {
    "mcp": "./mcp.json",
    "rules": "./rules",
    "agents": "./agents"
  }
}

6. GitHub Copilot Extension Structure

GitHub Copilot extensions package custom agent participants (@participant), scoped instruction sets, and MCP servers into repository-level or marketplace bundles defined by a manifest.

<extension-name>/
├── copilot-extension.json   # Copilot extension manifest
├── mcp.json                 # Tool and MCP server integrations
├── instructions/            # Scoped prompt instruction markdown files
│   └── pr-review.md
└── agents/                  # Custom agent participant definitions
    └── reviewer.json
Manifest Schema (copilot-extension.json):
{
  "id": "copilot-pr-reviewer",
  "version": "1.0.0",
  "description": "Automated pull request review participant and CI MCP tools",
  "mcp": "./mcp.json",
  "instructions": "./instructions",
  "agents": "./agents"
}

7. Kilo Code & Aider Plugin Structures

Kilo Code Plugin Structure

Kilo Code plugins bundle custom execution modes (modes/), skill toolkits, and settings into a directory defined by plugin.json or kilo-extension.json.

<plugin-name>/
├── plugin.json              # Plugin manifest
├── kilo.jsonc               # Tool configurations, MCP servers, and hooks
├── modes/                   # Custom execution mode definitions (e.g., Ask, Architect)
│   └── security-mode.json
└── skills/                  # Progressive disclosure skills
Aider Plugin Structure

Aider plugins use Python modules or package scripts to define custom slash commands, paired with configuration overlays in .aider.conf.yml.

<plugin-name>/
├── __init__.py              # Python entrypoint defining custom commands and hooks
├── .aider.conf.yml          # Bundled convention overrides, test/lint hooks, and MCP servers
└── skills/                  # Prompt templates and custom script helpers

Namespacing Implementations & Collision Prevention

When plugins bundle multiple capabilities (MCP tools, skills, subagents, execution hooks, and rules), name collisions become a significant risk if two packages export identical identifiers (e.g., two plugins defining a lint skill, a deploy MCP tool, or a reviewer subagent). Agent platforms handle namespacing through distinct isolation strategies:

1. Google Antigravity & Antigravity CLI

Antigravity enforces hierarchical namespacing derived from the plugin’s root directory name or name field in plugin.json:

  • MCP Server & Tool Scoping: MCP servers declared inside a plugin are automatically isolated under the plugin’s namespace. Tools are exposed to the agent model with prefixed identifiers: <plugin_name>:<server_name>.<tool_name>.
  • Skill & Subagent Addressing: Skills and custom subagents are indexed with their package namespace. When invoking subagents or reading skills via progressive disclosure, the runtime resolves <plugin_name>/<skill_name> and <plugin_name>:<agent_name> to prevent shadowing local project definitions.
  • Hook & Rule Scoping: Execution hooks and rules/ within a plugin only trigger for tasks, tools, or file paths explicitly managed by that plugin, preventing third-party rules from globally overriding workspace policies.

2. Claude Code

Claude Code employs colon-separated namespace delimiters for plugin contributions:

  • Skills & Slash Commands: Plugin-contributed skills and custom commands are registered under the plugin prefix. For a plugin named security-pack, its skills are invoked or referenced as /security-pack:audit or <security-pack:audit>.
  • MCP Tool Prefixing: MCP servers defined in the plugin’s .mcp.json are isolated so that exported tool names are namespaced (e.g., security-pack__scan_vulns), ensuring they do not collide with user-level ~/.claude.json servers.

3. GitHub Copilot

GitHub Copilot isolates extensions at the conversational entrypoint:

  • Participant @ Handles: Each Copilot extension registers as a distinct participant handle (e.g., @azure, @github, or @custom-plugin).
  • Command Routing: Commands and slash actions are namespaced under the participant: @custom-plugin /review or @custom-plugin /deploy. Tool invocations and prompt instructions are only activated when the specific participant is mentioned in the prompt.

4. Cursor

Cursor relies on extension package IDs and glob-targeted rule isolation:

  • Rule File Scoping: Rule files (.mdc) inside extensions use frontmatter globs and extension package IDs. Rules are only injected into context when active editor files match the extension’s glob criteria.
  • MCP & Agent Namespacing: Custom subagents and MCP tools are registered using the extension’s reverse-domain or package identifier (e.g., cursor.extension-id.toolName).

5. OpenCode & OpenAI Codex

OpenCode and Codex use hierarchical key nesting in configuration manifests:

  • Merged Config Isolation: In OpenCode (opencode.json), plugin MCP declarations are merged under namespaced dictionary keys ("mcp": { "plugin-name/server-name": { ... } }).
  • Subagent Namespacing: Codex and OpenCode index subagents in agents/ using the plugin folder path as a namespace prefix (e.g., plugin-name/architect), ensuring global subagent discovery lists remain disambiguated.

6. Kilo Code & Aider

  • Kilo Code Modes: Custom modes defined in modes/ are namespaced as mode:<plugin_name>:<mode_name>, allowing users to switch between specialized execution profiles without overwriting core modes (Code, Architect, Ask).
  • Aider Python Packaging: Aider plugins rely on standard Python module namespacing (aider.plugins.<plugin_name>). Custom commands and lint/test hooks execute within their isolated module scope, avoiding global namespace pollution in the runtime Python process.

Graph View