Agent OS - The Standards Layer for Claude Code and Cursor

You use Claude Code or Cursor. T

he AI is excellent at writing code, but it doesn’t know that your team always returns API responses as { data, error } envelopes, never uses Tailwind’s @apply, and writes controllers in past-tense verbs.

So you keep typing the same paragraph at the start of every chat.

Agent OS captures those conventions into versioned markdown standards and injects them into the AI’s context whenever they’re relevant.

What is Agent OS?

Agent OS is not an AI assistant.

It is a set of slash commands and profile templates you install into your project so that the AI coding tools you already use — Claude Code, Cursor, Antigravity — consistently follow your codebase’s conventions.

The project is bash scripts and markdown files.

There’s no runtime, no daemon, no API keys, no container. The “runtime” is whichever AI coding tool you already pay for.

“Agent OS helps you shape better specs, keeps agents aligned in a lightweight system that fits how you already build. Works alongside Claude Code, Cursor, Antigravity, and other AI tools. Any language, any framework.”

Agent OS on GitHub Agent OS Website Brian Casel on YouTube

What makes it different

• 📚 Standards capture — /discover-standards walks your codebase, surfaces recurring patterns, and writes them as versioned markdown
• 💉 Smart injection — /inject-standards picks the right standards for the current context (Plan Mode, conversation, building a Claude Skill)
• 🗺️ Indexed automatically — /index-standards maintains an index.yml so injection knows what’s available
• 📐 Plan-Mode-friendly spec shaping — /shape-spec adds targeted questions on top of Claude Code’s Plan Mode, considering your standards + product mission
• 🔁 Profile-based reuse — capture standards in one project, sync them back to a profile, inherit from that profile in the next project
• 🪶 Pure markdown + bash — no Node process, no container, no daemon, no provider lock-in
• ⚖️ MIT licensed — fully open source

Where Agent OS Sits in the AI Stack

Across recent posts on this site we’ve covered a five-layer AI tooling stack. Agent OS lives at the coding standards layer — distinct from both the personal assistants you message and the coding agents that actually write code:

Concretely:

• Personal assistants (NanoClaw / OpenClaw / Hermes) are AI agents that use code. You message them on Slack and they answer.
• Coding agent harnesses (Pi / Claude Code / Codex / Cursor) are AI agents that write code. You run them in your terminal and they edit files.
• Agent OS is a system that helps the coding agents understand your code. You install it into a project so that when Claude Code or Pi writes new files, they follow the same conventions as your existing files.

They’re complementary, not competing. A serious AI-first developer probably wants:

1. A coding agent harness (Pi, Claude Code, Cursor, Codex) to write the code → Agent OS keeps it consistent with your codebase
2. A personal AI assistant (NanoClaw, OpenClaw, or Hermes) for everything else — Slack triage, scheduled briefings, voice queries

Agent OS doesn’t replace either of those. It’s the connective tissue that makes the coding agent you’re already using fit your project.

The five design principles (the actual pitch)

Feature bullets are easy — the real argument for Agent OS is in the philosophy:

1. Build on top of AI tools, not around them. The v3 changelog (January 2026) is unusually candid about retreating from earlier responsibilities: spec writing, task breakdown, implementation orchestration were dropped because Claude Code’s Plan Mode and extended thinking handle them better. Agent OS deliberately shrinks to the layer AI tools don’t do well — codifying your codebase’s conventions.

2. Standards are markdown, not config. Every standard is a .md file that any human can read, edit in a PR, or grep. There’s no schema, no DSL, no special parser. The file is the prompt that gets injected.

3. Detection over assumption. /discover-standards reads your actual code to surface patterns, instead of asking you to fill in a template. It then suggests standards for you to confirm — you stay in the loop, but you don’t write them from scratch.

4. Inject only what’s relevant. Loading every standard you’ve ever captured into every prompt would balloon context and dilute signal. /inject-standards reads index.yml and picks the standards that apply to the current task, formatted differently for “chatting in plan mode” vs “building a Claude Skill” vs “implementing right now.”

5. Profile inheritance for the multi-project life. Most AI-first developers work across multiple codebases. Capture standards in your strongest project, sync them to a profile, and the next project you project-install.sh into starts from those instead of a blank slate.

The combination is the differentiator: Agent OS resists doing things AI tools already do well, and concentrates on the one job AI tools genuinely can’t do without you — knowing what your code looks like.

Self-Hosting Agent OS

There is no Docker setup — Agent OS is not a server. The “install” is copying markdown files into your project. But there are still some details worth getting right.

Install

# 1. Clone Agent OS once, anywhere
git clone https://github.com/buildermethods/agent-os ~/agent-os

# 2. From your project root, install it
~/agent-os/scripts/project-install.sh

This creates .claude/commands/agent-os/*.md (the slash commands) and agent-os/ (your project’s standards + specs + product docs).

First-time workflow

# In Claude Code, after running the installer:
/discover-standards
# → Claude reads your codebase, suggests patterns, writes them to agent-os/standards/

/index-standards
# → Generates agent-os/standards/index.yml

# Then whenever you start a new task:
/inject-standards
# → Auto-picks relevant standards from index.yml

# Or in plan mode:
/shape-spec
# → Asks targeted questions, saves plan to agent-os/specs/

Profile inheritance for cross-project reuse

# After discovering good standards in one project:
~/agent-os/scripts/sync-to-profile.sh --profile rails

# Then in a new project:
~/agent-os/scripts/project-install.sh --profile rails
# → New project starts with your captured rails standards

Define inheritance in config.yml:

version: 3.0
default_profile: default

profiles:
  rails:
    inherits_from: default
  rails-shopify:
    inherits_from: rails

A rails-shopify project install gets default + rails + rails-shopify standards, layered.

~/agent-os/scripts/project-install.sh --commands-only

Agent OS vs Other AI-Coding-Tool Add-Ons

Cursor Rules and Claude Code memory (CLAUDE.md) are the closest comparisons. Both are simpler, both are tool-specific. Agent OS adds: automatic standards discovery, indexed injection, cross-project profile inheritance, and an explicit Plan Mode workflow — at the cost of being a more involved system to learn.

Conclusion

Agent OS is a small, specific tool for a real problem: getting AI coding tools to follow your codebase’s conventions, consistently, without you re-explaining them every prompt. The v3 release sharpened it by dropping scope that Claude Code’s Plan Mode now handles better, leaving only the parts that don’t have AI-native solutions: discovery, indexing, injection.

If you primarily use Claude Code or Cursor and find yourself repeatedly typing “remember to use our ApiResponse<T> wrapper” at the start of every session, Agent OS is the right shape of fix. If you don’t use AI coding tools day-to-day, this isn’t the project for you.

Related tools worth knowing:

• OpenClaw — personal AI assistant runtime for messaging + voice; complementary layer
• NanoClaw — minimalist personal assistant; also complementary
• Cursor Rules — Cursor’s built-in equivalent; simpler, Cursor-only
• Claude Code memory (CLAUDE.md) — Anthropic’s official “tell Claude about your project” file; Claude-Code-only
• Claude Cookbooks — task-specific prompt patterns; lower-level than Agent OS