A comprehensive specification for building and managing Open Agent Systems—project structures that transform AI coding assistants into general-purpose agents for any domain.
- What Is an Open Agent System?
- Core Architecture
- The Mandatory Read Directive ← Most important requirement
- Folder Structure
- Agent File Anatomy
- The Command System
- The INSTRUCTIONS.md File
- Operations Guide
- Adding to an Existing Project
- Complete Example
An Open Agent System is a folder structure and set of markdown files that reconfigures AI coding assistants (Claude Code, Gemini CLI, Codex, etc.) to perform specialized, non-coding tasks. Instead of writing code, the AI manages files, performs research, transforms content, and executes domain-specific workflows.
Claude Code, Gemini CLI, and similar tools are general-purpose agent frameworks that happen to be configured for coding by default. Their fundamental capability is:
- Reading and writing files
- Following complex instructions
- Using tools (web search, shell commands, etc.)
- Managing context across conversations
This capability set works for any file-based workflow—not just code. An Open Agent System provides the structure to redirect these capabilities toward your specific domain.
Problem: Building custom AI agents requires software engineering—writing code, managing deployments, building UIs, maintaining infrastructure.
Solution: Open Agent Systems let you define agent behavior in markdown files. No code required. The AI reads your instructions and becomes that agent.
Benefit: You can create sophisticated multi-agent workflows using nothing but folders and markdown files, runnable in any AI coding assistant.
A key feature of Open Agent Systems is tool agnosticism. The same system works with:
- Claude Code (via
CLAUDE.md) - Codex (via
AGENTS.md) - Gemini CLI (via
GEMINI.md)
All three point to the same INSTRUCTIONS.md file. You write your agents once and use them with any tool.
Open Agent Systems use a three-layer architecture:
┌─────────────────────────────────────────────────────────┐
│ CLAUDE.md / AGENTS.md / GEMINI.md │
│ (Tool-specific entry points - augmented with pointer) │
└────────────────────────┬────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ open-agents/INSTRUCTIONS.md │
│ (Agent index: lists all agents with descriptions) │
│ (Routing logic: when to use which agent) │
│ (Loaded into context at conversation start) │
└────────────────────────┬────────────────────────────────┘
│
▼ (on demand only)
┌─────────────────────────────────────────────────────────┐
│ open-agents/agents/researcher.md transformer.md ... │
│ (Full agent definitions - loaded when triggered) │
└─────────────────────────────────────────────────────────┘
This is the most important requirement of the entire system.
Each entry point file (CLAUDE.md, AGENTS.md, GEMINI.md) MUST include a read directive at the top. Without this, the agent system won't function.
**CRITICAL: Read `open-agents/INSTRUCTIONS.md` immediately.**That's it. One line. The AI will read the file and understand the system.
When setting up an Open Agent System, always create entry point files if they don't exist:
CLAUDE.md— for Claude CodeAGENTS.md— for CodexGEMINI.md— for Gemini CLI
Since you're already creating .claude/commands/ and .gemini/commands/ folders, create these files too. A minimal entry point file is just:
**CRITICAL: Read `open-agents/INSTRUCTIONS.md` immediately.**If the project already has these files, add the directive at the top.
Progressive Disclosure: Agent definitions can be large (hundreds of lines). Loading all agents into context at once wastes tokens and creates noise. Instead:
- At conversation start, only
INSTRUCTIONS.mdis loaded INSTRUCTIONS.mdcontains brief descriptions of each agent- Full agent files are loaded only when that agent is triggered
Context Management: AI assistants have limited context windows. The pointer pattern keeps initial context small while allowing complex agent definitions.
Single Source of Truth: All tool-specific entry points (CLAUDE.md, AGENTS.md, GEMINI.md) point to the same instructions. Update once, works everywhere.
Non-Disruptive: The Open Agent System lives in its own folder (open-agents/) and augments existing project files rather than replacing them.
| Layer | File(s) | Responsibility |
|---|---|---|
| Entry | CLAUDE.md, AGENTS.md, GEMINI.md |
Tool detection, pointer to instructions |
| Index | open-agents/INSTRUCTIONS.md |
Agent catalog, routing logic, workflow docs |
| Agents | open-agents/agents/*.md |
Full agent definitions, behaviors, formats |
Open Agent Systems live in a single open-agents/ folder at the project root. This isolates the agent system from the rest of the project and prevents conflicts with existing files.
existing-project/
├── (existing project files...)
├── CLAUDE.md # Augmented with pointer
├── AGENTS.md # Augmented with pointer
├── GEMINI.md # Augmented with pointer
│
└── open-agents/ # The agent system container
├── README.md # Human-readable intro
├── INSTRUCTIONS.md # Agent index and routing
│
├── agents/ # Agent definitions
│ ├── researcher.md
│ ├── transformer.md
│ └── publisher.md
│
├── tools/ # Agent-created scripts (optional)
│ └── (scripts created by agents)
│
├── source/ # User inputs
│ └── (raw materials, requests, stubs)
│
├── output-drafts/ # First-stage outputs
│ └── (initial processing results)
│
├── output-refined/ # Second-stage outputs
│ └── (refined, reviewed content)
│
└── output-final/ # Final deliverables
└── (publication-ready materials)
- Isolation: The entire agent system is contained in one folder
- Non-disruptive: Doesn't overwrite existing project files
- Portable: Can be copied between projects
- Clear separation: Agent system vs. project code is obvious
| Folder | Purpose | Example Contents |
|---|---|---|
agents/ |
Agent definitions | researcher.md, transformer.md |
tools/ |
Scripts created by agents | compress_audio.sh, resize_image.py |
source/ |
Raw inputs from user | Notes, stubs, requests, reference materials |
output-drafts/ |
First processing stage | Drafts, initial transforms, rough outputs |
output-refined/ |
Intermediate stage | Reviewed, refined, or transformed outputs |
output-final/ |
Final deliverables | Publication-ready materials |
Rename output folders to match your domain:
Video Production:
output-scripts/
output-production/
output-final/
Research Project:
output-notes/
output-analysis/
output-papers/
Content Creation:
output-drafts/
output-reviewed/
output-published/
An agent file is a markdown document in open-agents/agents/ that defines:
- What the agent does
- When it should be activated
- How it should behave
- What output it produces
- Where output goes
Every agent file should contain these sections:
# [Agent Name]
[1-2 sentence description of what this agent does]
---
## Purpose
[Expanded description: what problem does this agent solve?
What is its role in the system? What makes it valuable?]
---
## When to Use This Agent
Use this agent when the user:
- [Trigger phrase or condition]
- [Another trigger]
- [Another trigger]
---
## Core Behaviors
### 1. [First Behavior]
[Description of what the agent does]
### 2. [Second Behavior]
[Description]
### 3. [Third Behavior]
[Description]
---
## Output Format
[Define the structure of what the agent produces.
Use code blocks to show templates if helpful.]
---
## Output Location
Save outputs to: `open-agents/[folder]/[filename_pattern]`
Examples:
- `open-agents/output-drafts/example_filename.ext`
- `open-agents/output-final/another_example.ext`
---
## Examples
[Optional but recommended: show example inputs and outputs]
> Example prompt: "[user request]"
> Example output: [what the agent would produce]1. Single Responsibility Each agent should do one thing well. If an agent does too much, split it.
2. Clear Triggers Make it obvious when this agent should be used vs. another. The "When to Use" section is critical for routing.
3. Explicit Output Location Always tell the agent where to save its work. Ambiguity causes confusion.
4. Behavioral, Not Technical Describe what the agent should do, not how it should implement. Let the AI figure out implementation.
5. Include Examples Examples are the most effective way to communicate expectations. Include at least one.
6. Consider Tool Creation Agents may benefit from writing their own scripts/tools for repeatable operations. See Agent-Created Tools below.
# History Researcher
Researches historical topics and produces rich markdown articles with images and links.
---
## Purpose
This agent creates comprehensive, engaging articles about historical topics.
It can originate content from a topic name or expand existing stub files.
---
## When to Use This Agent
Use this agent when the user:
- Asks to "research" a historical topic
- Asks to "expand" or "deepen" an existing article
- Asks to "write about" a historical subject
- Provides a stub file and wants it filled in
---
## Core Behaviors
### 1. Research Thoroughly
Use web search to gather dates, events, figures, and context.
Prioritize interesting details over dry facts.
### 2. Write Engagingly
Produce narrative prose, not encyclopedia entries.
Multi-paragraph depth for each major section.
### 3. Include Visuals
Add markdown image references throughout:
``
---
## Output Format
```markdown
# [Topic Title]
> [One-sentence hook]
## Introduction
[2-3 paragraphs setting the stage]
## [First Major Era]
[Multiple paragraphs with images]
## [Continue as needed...]
## Legacy and Impact
[Why this matters today]
## Further Reading
- [Links to sources]Save to: open-agents/output-articles/
Filename: topic_name.md (lowercase, underscores)
"Research the history of Disney animation"
Creates open-agents/output-articles/disney_animation.md with a 2,000-4,000 word
article covering Disney's founding through present day.
### Agent-Created Tools
Agents can create their own scripts and tools to handle repeatable operations more efficiently. Instead of regenerating the same logic via the LLM every time, an agent can write a script once and reuse it.
#### When to Create Tools
Consider tool creation when an agent:
- Performs the same file manipulation repeatedly (resize images, compress audio, convert formats)
- Executes complex shell commands that are error-prone to generate each time
- Needs precise, deterministic behavior (not probabilistic LLM output)
- Would benefit from faster execution (scripts run faster than LLM reasoning)
#### Tool Location
Store agent tools in a `tools/` subfolder within `open-agents/`:
open-agents/ ├── INSTRUCTIONS.md ├── agents/ │ ├── audio_processor.md │ └── image_optimizer.md └── tools/ ├── compress_audio.sh ├── resize_image.py └── convert_format.js
#### Referencing Tools in Agent Files
When an agent has associated tools, document them:
```markdown
## Available Tools
This agent has access to the following scripts:
### `open-agents/tools/compress_audio.sh`
Compresses audio files to a target bitrate.
Usage: `./open-agents/tools/compress_audio.sh <input> <output> <bitrate>`
### `open-agents/tools/normalize_volume.sh`
Normalizes audio volume to -14 LUFS.
Usage: `./open-agents/tools/normalize_volume.sh <input> <output>`
When performing these operations, use the scripts rather than
constructing the ffmpeg commands manually each time.
An agent can be designed to create its own tools when needed. Include this capability in the agent definition:
## Tool Creation
If you find yourself repeating the same operation multiple times,
consider writing a reusable script:
1. Create the script in `open-agents/tools/`
2. Make it executable: `chmod +x open-agents/tools/script_name.sh`
3. Document it in this agent file under "Available Tools"
4. Use it for future operations
This improves reliability (deterministic behavior) and speed
(no LLM reasoning required for repeated operations).Commands provide predictable invocation of agents. Instead of hoping the AI recognizes a trigger phrase, you can explicitly call:
/history research Disney animation
/history html disney_animation.md
/history extract disney_animation.md
Open Agent Systems maintain commands for multiple tools:
.claude/commands/ # Claude Code commands
└── {domain}/
├── {command1}.md
└── {command2}.md
.gemini/commands/ # Gemini CLI commands
└── {domain}/
└── (same structure)
Commands are organized by domain (e.g., history/, video/, research/).
Commands are simple—they instruct the AI to use an agent:
[Brief description of what this command does]
Follow the instructions in `open-agents/agents/{name}.md` to complete this task.
$ARGUMENTSThe $ARGUMENTS placeholder passes any user input after the command name.
.claude/commands/history/research.md:
Research a historical topic and create a comprehensive article.
Follow the instructions in `open-agents/agents/researcher.md`.
$ARGUMENTSThe same file should exist at .gemini/commands/history/research.md.
Tool Agnosticism: Users should be able to use their preferred tool. Maintaining both command structures ensures the system works regardless of which AI assistant is used.
Identical Content: The command files are usually identical between .claude/ and .gemini/. When you create or update a command, update both locations.
Structure: .claude/commands/{domain}/{action}.md
{domain}= the subject area (history, video, research, etc.){action}= what the command does (research, transform, publish)
Examples:
/history research→.claude/commands/history/research.md/video critique→.claude/commands/video/critique.md
System operations (adding, editing, removing agents) are documented directly in INSTRUCTIONS.md rather than as separate commands. This keeps the system simpler and ensures the guidance is always available without additional command files. See Operations Guide for details.
INSTRUCTIONS.md is the most important file in an Open Agent System. It:
- Describes the system's purpose
- Lists all available agents
- Defines routing logic
- Documents workflow
- Sets behavioral rules (like git commit protocol)
# [System Name]
[Brief description of what this system does]
---
## How This System Works
[Explain the pointer pattern, progressive disclosure]
---
## Project Structure
[Document the folder structure with descriptions]
---
## Available Agents
### 1. [Agent Name] (`agents/file.md`)
**Purpose:** [What it does]
**When to use:**
- [Trigger conditions]
**Output:** [Where results go]
**To use this agent:** Read `open-agents/agents/file.md`
### 2. [Next Agent]
...
---
## Routing Logic
| User says... | Agent to use |
|--------------|--------------|
| "[trigger phrase]" | [Agent name] |
| "[another phrase]" | [Agent name] |
---
## Git Commit Protocol
[Define when and how to commit]
---
## File Naming Conventions
[Define naming patterns]
---
## Quick Start
[Brief getting-started guide]Each agent entry should be brief but complete enough for routing:
### 1. The Researcher (`agents/researcher.md`)
**Purpose:** Research historical topics and produce rich markdown articles.
**When to use:**
- User asks to "research" a topic
- User asks to "expand" or "deepen" an article
- User asks to "write about" something
- User provides a stub file
**Output:** Markdown files in `open-agents/output-articles/`
**To use this agent:** Read `open-agents/agents/researcher.md`The routing table helps the AI decide which agent to invoke:
## Routing Logic
| User says... | Agent to use |
|--------------|--------------|
| "Research the history of X" | Researcher |
| "Expand this article" | Researcher |
| "Create an HTML page from this" | HTML Generator |
| "Extract the data into JSON" | Data Extractor |
| "Create all outputs for this" | Researcher → HTML → Extractor (chain) |If agents can be chained, document the workflow:
## Workflow
A common flow through this system:
1. **Research:** User provides a topic → Researcher creates article
2. **Transform:** Article → HTML Generator creates webpage
3. **Extract:** Article → Data Extractor creates JSON
Agents can be used independently or in sequence.Follow these steps to create a system from scratch:
mkdir -p open-agents/{agents,tools,source,output-drafts,output-refined,output-final}
mkdir -p .claude/commands/{domain}
mkdir -p .gemini/commands/{domain}Create open-agents/README.md:
# Open Agent System
This folder contains an **Open Agent System**—a collection of markdown-defined agents that transform AI coding assistants into specialized tools for [your domain].
## What's Here
- `INSTRUCTIONS.md` — Full documentation, agent index, and routing logic
- `agents/` — Individual agent definitions
- `source/` — Input materials
- `output-*/` — Processing stages
## Quick Start
Read `INSTRUCTIONS.md` for available agents and how to use them.Create open-agents/INSTRUCTIONS.md with:
- System description
- Project structure documentation
- Agent index (initially empty or with planned agents)
- Routing logic
- Git commit protocol
For each agent, create open-agents/agents/{name}.md with:
- Purpose
- When to use
- Core behaviors
- Output format
- Output location
For each agent, create commands in both:
.claude/commands/{domain}/{command}.md.gemini/commands/{domain}/{command}.md
Include guidance for managing the system directly in INSTRUCTIONS.md:
## Managing This System
### Adding a New Agent
1. Create `open-agents/agents/{name}.md` with purpose, triggers, behaviors, output format
2. Create commands in `.claude/commands/{domain}/` and `.gemini/commands/{domain}/`
3. Add agent entry to "Available Agents" section above
4. Add routing entries to the routing table
### Editing an Agent
1. Modify `open-agents/agents/{name}.md`
2. Update commands if invocation changes
3. Update routing table if triggers change
### Removing an Agent
1. Delete the agent file and command files
2. Remove from "Available Agents" and routing tableCreate open-agents/agents/{name}.md following the agent anatomy template.
Create .claude/commands/{domain}/{command}.md:
[Brief description]
Follow the instructions in `open-agents/agents/{name}.md`.
$ARGUMENTSCreate identical file in .gemini/commands/{domain}/.
Add an entry to the "Available Agents" section:
### [N]. [Agent Name] (`agents/{name}.md`)
**Purpose:** [Description]
**When to use:**
- [Triggers]
**Output:** [Location]Add routing entries to the routing table.
git add open-agents/agents/{name}.md
git add .claude/commands/{domain}/{command}.md
git add .gemini/commands/{domain}/{command}.md
git add open-agents/INSTRUCTIONS.md
git commit -m "Add {agent name} agent"Find both components:
- Definition:
open-agents/agents/{name}.md - Commands:
.claude/commands/{domain}/{command}.mdand.gemini/commands/{domain}/{command}.md
Read the files. Understand:
- What the agent currently does
- What triggers it
- Where output goes
Edit the agent file to modify behavior. Common changes:
- Adding new behaviors
- Changing output format
- Adjusting triggers
- Updating examples
If triggers changed, update open-agents/INSTRUCTIONS.md:
- Agent description in "Available Agents"
- Routing table entries
git add -A
git commit -m "Update {agent name}: {what changed}"rm open-agents/agents/{name}.md
rm .claude/commands/{domain}/{command}.md
rm .gemini/commands/{domain}/{command}.mdRemove:
- Entry from "Available Agents"
- Rows from routing table
git add -A
git commit -m "Remove {agent name} agent"To completely change the system's purpose:
Decide:
- What agents are needed?
- What folder structure makes sense?
- What workflow should outputs follow?
Rename output folders to match the new domain:
mv open-agents/output-drafts open-agents/output-scriptsEither modify existing agents or delete and create new ones.
open-agents/INSTRUCTIONS.md: Complete rewriteopen-agents/README.md: Update for new purpose- Entry point files: Update the Open Agent section
Remove old content from source and output folders.
Open Agent Systems are designed to augment existing projects without disrupting them. This section explains how to add an agent system to a project that already has CLAUDE.md, AGENTS.md, or GEMINI.md files.
Instead of replacing existing entry point files, append a section that points to the Open Agent System:
---
## Open Agents
This project includes an **Open Agent System** for [brief description of what the agents do].
**To use the agent system:** Read `open-agents/INSTRUCTIONS.md`
### Quick Reference
| Agent | Trigger | Output |
|-------|---------|--------|
| [Agent 1] | "[trigger phrase]" | `open-agents/output-*/` |
| [Agent 2] | "[trigger phrase]" | `open-agents/output-*/` |mkdir -p open-agents/{agents,tools,source,output-drafts,output-refined,output-final}This provides human-readable context for anyone browsing the folder:
# Open Agent System
This folder contains an **Open Agent System**—a structure of markdown files that transform AI coding assistants (Claude Code, Gemini CLI, Codex) into specialized agents.
## What Is This?
Instead of writing code, these agents:
- Manage files and content
- Perform research
- Transform documents between formats
- Execute domain-specific workflows
The agents are defined in markdown. No code required.
## Getting Started
Read `INSTRUCTIONS.md` for:
- Available agents and what they do
- How to invoke each agent
- Routing logic (which agent handles which requests)
## Folder Structure
- `agents/` — Agent definition files
- `tools/` — Scripts created by agents for repeatable operations
- `source/` — Input materials (your raw content goes here)
- `output-*/` — Processing stages (drafts → refined → final)Create the full instructions file following the template in Section 6.
Add agents to open-agents/agents/ following the template in Section 4.
Add commands to .claude/commands/{domain}/ and .gemini/commands/{domain}/.
Create these files if they don't exist, or add the directive to the top if they do:
CLAUDE.md, AGENTS.md, GEMINI.md:
**CRITICAL: Read `open-agents/INSTRUCTIONS.md` immediately.**That's the minimum requirement. Optionally add a quick reference table below for convenience.
- Don't replace existing
CLAUDE.mdcontent—append to it - Don't put agent files at project root—keep them in
open-agents/ - Don't modify the project's existing folder structure
- Don't add numbered prefixes to existing project folders
After integration, confirm:
open-agents/README.mdexists and is human-readableopen-agents/INSTRUCTIONS.mdlists all agents- Entry point files (
CLAUDE.md, etc.) have the Open Agents section - Slash commands exist in
.claude/commands/and.gemini/commands/ - Running
/your-domain commandinvokes the correct agent
A working Open Agent System for researching historical topics, added to an existing project:
my-existing-project/
├── src/ # Existing project code
├── package.json # Existing project files
├── CLAUDE.md # Augmented with Open Agents section
├── AGENTS.md # Augmented with Open Agents section
├── GEMINI.md # Augmented with Open Agents section
│
├── .claude/commands/
│ └── history/
│ ├── research.md
│ ├── html.md
│ └── extract.md
│
├── .gemini/commands/
│ └── history/
│ └── (same structure)
│
└── open-agents/
├── README.md
├── INSTRUCTIONS.md
│
├── agents/
│ ├── researcher.md
│ ├── html_generator.md
│ └── data_extractor.md
│
├── source/
│ ├── disney_animation.md # Stub file
│ ├── video_games.md # Stub file
│ └── manga_origins.md # Stub file
│
├── output-articles/
├── output-html/
└── output-data/
**CRITICAL: Read `open-agents/INSTRUCTIONS.md` immediately.**
[... any existing project instructions ...]
### Quick Reference
| Agent | Trigger | Output |
|-------|---------|--------|
| Researcher | "research [topic]" | `open-agents/output-articles/` |
| HTML Generator | "create HTML from [file]" | `open-agents/output-html/` |
| Data Extractor | "extract data from [file]" | `open-agents/output-data/` |
### Available Commands
- `/history research [topic]` — Research and create article
- `/history html [file]` — Generate HTML from article
- `/history extract [file]` — Extract structured JSON# Open Agent System: History Research
This folder contains an Open Agent System for researching historical topics and transforming them into multiple output formats.
## Agents
- **Researcher** — Creates comprehensive markdown articles
- **HTML Generator** — Transforms articles into themed webpages
- **Data Extractor** — Extracts structured JSON from articles
## Getting Started
1. Add a stub file to `source/` with your topic
2. Ask the Researcher to expand it: "Research the history of [topic]"
3. Transform to HTML: "Create HTML from [filename]"
4. Extract data: "Extract data from [filename]"
Full documentation: `INSTRUCTIONS.md`# History Research System
An open agent system for researching historical topics.
---
## How This System Works
1. **Entry points** (CLAUDE.md/AGENTS.md/GEMINI.md) point here
2. **This file** is the index—it describes available agents
3. **Agent files** load on demand when triggered
---
## Available Agents
### 1. The Researcher (`agents/researcher.md`)
**Purpose:** Research historical topics and produce rich markdown articles.
**When to use:**
- User asks to "research" a topic
- User asks to "expand" an existing article
- User provides a stub file
**Output:** Markdown files in `open-agents/output-articles/`
### 2. The HTML Generator (`agents/html_generator.md`)
**Purpose:** Transform markdown articles into themed HTML pages.
**When to use:**
- User asks to "create HTML"
- User asks to "make a webpage"
**Output:** HTML files in `open-agents/output-html/`
### 3. The Data Extractor (`agents/data_extractor.md`)
**Purpose:** Extract structured JSON from articles.
**When to use:**
- User asks to "extract data"
- User asks to "create JSON"
**Output:** JSON files in `open-agents/output-data/`
---
## Routing Logic
| User says... | Agent |
|--------------|-------|
| "Research the history of X" | Researcher |
| "Expand this article" | Researcher |
| "Create HTML from this" | HTML Generator |
| "Extract data into JSON" | Data Extractor |
| "Create all outputs" | Researcher → HTML → Extractor |Research a historical topic and create a comprehensive markdown article.
Follow the instructions in `open-agents/agents/researcher.md`.
$ARGUMENTS# The History of Disney Animation
> From a small studio in Los Angeles to the most influential animation
> company in the world.
<!-- Stub file. Ask the Researcher to expand this. -->An Open Agent System consists of:
- A container folder (
open-agents/) that isolates the system - A README.md for human-readable orientation
- An INSTRUCTIONS.md that catalogs agents and routes requests
- Agent definitions (
agents/*.md) that define specialized behaviors - Commands (
.claude/commands/,.gemini/commands/) for explicit invocation - Structured folders (
source/,output-*/) for organized workflow - Entry point files (CLAUDE.md, AGENTS.md, GEMINI.md) with the read directive
Critical: Entry points must contain **CRITICAL: Read open-agents/INSTRUCTIONS.md immediately.** at the top. Create these files if they don't exist.
The pattern enables:
- Tool agnosticism: Works with Claude Code, Gemini CLI, Codex
- Progressive disclosure: Only loads what's needed
- Domain flexibility: Reconfigurable for any file-based workflow
- Non-disruptive integration: Adds to existing projects without conflict
- Self-modification: Can add, edit, and remove agents
To create a new system: open-agents/ folder → README → INSTRUCTIONS → agents → commands → augment entry points with mandatory read directive.
To add to existing project: create open-agents/, add mandatory read directive to CLAUDE.md/AGENTS.md/GEMINI.md.
This definition document describes the Open Agent System specification.