diff --git a/plugins/agent-os/extensions/backend/system_prompt/_50_agent_os_context.py b/plugins/agent-os/extensions/backend/system_prompt/_50_agent_os_context.py
new file mode 100644
index 00000000..b16a2e57
--- /dev/null
+++ b/plugins/agent-os/extensions/backend/system_prompt/_50_agent_os_context.py
@@ -0,0 +1,9 @@
+from backend.utils.extension import Extension
+
+
+class AgentOsContext(Extension):
+
+    async def execute(self, system_prompt: list[str] = [], **kwargs):
+        prompt = self.agent.read_prompt("fw.agent_os.reference.md")
+        if prompt:
+            system_prompt.append(prompt)
diff --git a/plugins/agent-os/plugin.yaml b/plugins/agent-os/plugin.yaml
new file mode 100644
index 00000000..91f2bed7
--- /dev/null
+++ b/plugins/agent-os/plugin.yaml
@@ -0,0 +1,6 @@
+name: Agent OS
+description: Standards discovery, extraction, and deployment system for AI-assisted development. Keeps agents aligned with project coding conventions.
+version: 1.0.0
+settings_sections: []
+per_project_config: true
+per_agent_config: false
diff --git a/plugins/agent-os/prompts/fw.agent_os.discover_standards.md b/plugins/agent-os/prompts/fw.agent_os.discover_standards.md
new file mode 100644
index 00000000..7c1ad5ea
--- /dev/null
+++ b/plugins/agent-os/prompts/fw.agent_os.discover_standards.md
@@ -0,0 +1,128 @@
+# Discover Standards
+
+Extract tribal knowledge from your codebase into concise, documented standards.
+
+## Guidelines
+
+- **Write concise standards** -- Use minimal words. Standards must be scannable by AI agents without bloating context windows.
+- **Offer suggestions** -- Present options the user can confirm, choose between, or correct. Do not make them think harder than necessary.
+
+## Process
+
+### Step 1: Determine Focus Area
+
+Check if the user specified an area. If they did, skip to Step 2.
+
+If no area was specified:
+
+1. Analyze the codebase structure (folders, file types, patterns)
+2. Identify 3-5 major areas. Examples:
+   - **Frontend areas:** UI components, styling/CSS, state management, forms, routing
+   - **Backend areas:** API routes, database/models, authentication, background jobs
+   - **Cross-cutting:** Error handling, validation, testing, naming conventions, file structure
+3. Present the areas to the user and ask which one to focus on.
+
+Wait for user response before proceeding.
+
+### Step 2: Analyze and Present Findings
+
+Once an area is determined:
+
+1. Read key files in that area (5-10 representative files)
+2. Look for patterns that are:
+   - **Unusual or unconventional** -- Not standard framework/library patterns
+   - **Opinionated** -- Specific choices that could have gone differently
+   - **Tribal** -- Things a new developer would not know without being told
+   - **Consistent** -- Patterns repeated across multiple files
+3. Present findings and let the user select which to document.
+
+### Step 3: Ask Why, Then Draft Each Standard
+
+For each selected standard, complete this full loop before moving to the next:
+
+1. **Ask 1-2 clarifying questions** about the "why" behind the pattern
+2. **Wait for user response**
+3. **Draft the standard** incorporating their answer
+4. **Confirm with user** before creating the file
+5. **Create the file** if approved
+
+Example questions to ask (adapt based on the specific standard):
+- "What problem does this pattern solve? Why not use the default/common approach?"
+- "Are there exceptions where this pattern should not be used?"
+- "What is the most common mistake a developer or agent makes with this?"
+
+**Do NOT batch all questions upfront.** Process one standard at a time through the full loop.
+
+### Step 4: Create the Standard File
+
+For each standard (after completing Step 3 Q&A):
+
+1. Determine the appropriate folder (create if needed):
+   - `api/`, `database/`, `javascript/`, `css/`, `backend/`, `testing/`, `global/`
+2. Check if a related standard file already exists -- append to it if so
+3. Draft the content and confirm with the user
+4. Create or update the file in `agent-os/standards/[folder]/`
+5. Then repeat Steps 3-4 for the next selected standard
+
+### Step 5: Update the Index
+
+After all standards are created:
+
+1. Scan `agent-os/standards/` for all `.md` files
+2. For each new file without an index entry, propose a description
+3. Update `agent-os/standards/index.yml`:
+
+```yaml
+api:
+  response-format:
+    description: API response envelope structure and error format
+```
+
+Alphabetize by folder, then by filename.
+
+### Step 6: Offer to Continue
+
+Ask if the user wants to discover standards in another area.
+
+## Output Location
+
+All standards: `agent-os/standards/[folder]/[standard].md`
+Index file: `agent-os/standards/index.yml`
+
+## Writing Concise Standards
+
+Standards will be injected into AI context windows. Every word costs tokens. Follow these rules:
+
+- **Lead with the rule** -- State what to do first, explain why second (if needed)
+- **Use code examples** -- Show, do not tell
+- **Skip the obvious** -- Do not document what the code already makes clear
+- **One standard per concept** -- Do not combine unrelated patterns
+- **Bullet points over paragraphs** -- Scannable beats readable
+
+**Good example:**
+```markdown
+# Error Responses
+
+Use error codes: `AUTH_001`, `DB_001`, `VAL_001`
+
+{ "success": false, "error": { "code": "AUTH_001", "message": "..." } }
+
+- Always include both code and message
+- Log full error server-side, return safe message to client
+```
+
+**Bad example:**
+Long paragraphs explaining error handling philosophy in prose form. Standards should be scannable, not essays.
+
+## Full Loop Example
+
+1. Present findings for an area
+2. User selects which to document
+3. Ask why for first standard
+4. User explains the reasoning
+5. Draft the standard incorporating their answer
+6. User confirms
+7. Create the file
+8. Move to next standard and repeat
+
+Complete the full ask-draft-confirm-create cycle for each standard before starting the next one.
diff --git a/plugins/agent-os/prompts/fw.agent_os.index_standards.md b/plugins/agent-os/prompts/fw.agent_os.index_standards.md
new file mode 100644
index 00000000..925412b1
--- /dev/null
+++ b/plugins/agent-os/prompts/fw.agent_os.index_standards.md
@@ -0,0 +1,110 @@
+# Index Standards
+
+Rebuild and maintain the standards index file (`index.yml`).
+
+## Purpose
+
+The index enables inject-standards to suggest relevant standards without reading all files. It maps each standard to a brief description for quick matching.
+
+## Process
+
+### Step 1: Scan for Standards Files
+
+1. List all `.md` files in `agent-os/standards/` and its subfolders
+2. Build a list of all standards organized by folder:
+   ```
+   root/coding-style.md        # Files in standards/ root use "root" as the folder name
+   root/naming.md
+   api/response-format.md
+   api/error-handling.md
+   database/migrations.md
+   ```
+
+**Note:** `root` is a reserved keyword -- it refers to `.md` files directly in `agent-os/standards/` (not in a subfolder). Do not create an actual folder named "root".
+
+### Step 2: Load Existing Index
+
+Read `agent-os/standards/index.yml` if it exists. Note which entries already have descriptions.
+
+### Step 3: Identify Changes
+
+Compare the file scan with the existing index:
+
+- **New files** -- Standards files without index entries
+- **Deleted files** -- Index entries for files that no longer exist
+- **Existing files** -- Already indexed, keep as-is
+
+### Step 4: Handle New Files
+
+For each new standard file that needs an index entry:
+
+1. Read the file to understand its content
+2. Propose a one-sentence description to the user for confirmation
+
+Keep descriptions to **one short sentence** -- they are for matching, not documentation.
+
+### Step 5: Handle Deleted Files
+
+If there are index entries for files that no longer exist:
+
+1. List them for the user
+2. Remove them from the index automatically (no confirmation needed)
+
+Report the removed entries.
+
+### Step 6: Write Updated Index
+
+Generate `agent-os/standards/index.yml` with this structure:
+
+```yaml
+folder-name:
+  file-name:
+    description: Brief description here
+```
+
+**Rules:**
+- Alphabetize folders
+- Alphabetize files within each folder
+- File names without `.md` extension
+- One-line descriptions only
+
+**Example:**
+```yaml
+root:
+  coding-style:
+    description: General coding style, formatting, linting rules
+  naming:
+    description: File naming, variable naming, class naming conventions
+
+api:
+  error-handling:
+    description: Error codes, exception handling, error response format
+  response-format:
+    description: API response envelope structure, status codes, pagination
+
+database:
+  migrations:
+    description: Migration file structure, naming conventions, rollback patterns
+```
+
+**Note:** `root` appears first and contains standards files that live directly in `agent-os/standards/` (not in subfolders).
+
+### Step 7: Report Results
+
+Summarize what changed:
+- Number of new entries added
+- Number of stale entries removed
+- Number of entries unchanged
+- Total standards indexed
+
+## When to Run
+
+- After manually creating or deleting standards files
+- If inject-standards suggestions seem out of sync
+- To clean up a messy or outdated index
+
+**Note:** discover-standards runs this automatically as its final step, so you usually do not need to call it separately after discovering standards.
+
+## Output
+
+Updates `agent-os/standards/index.yml`
diff --git a/plugins/agent-os/prompts/fw.agent_os.inject_standards.md b/plugins/agent-os/prompts/fw.agent_os.inject_standards.md
new file mode 100644
index 00000000..66c37050
--- /dev/null
+++ b/plugins/agent-os/prompts/fw.agent_os.inject_standards.md
@@ -0,0 +1,82 @@
+# Inject Standards
+
+Inject relevant standards into the current context, formatted appropriately for the situation.
+
+## Usage Modes
+
+### Auto-Suggest Mode (no arguments)
+Analyzes context and suggests relevant standards.
+
+### Explicit Mode (with arguments)
+Directly injects specified standards without suggestions. Arguments can be:
+- **Folder name** -- `api` injects all `.md` files in `agent-os/standards/api/`
+- **Folder/file** -- `api/response-format` injects `agent-os/standards/api/response-format.md`
+- **Root folder** -- `root` injects all `.md` files directly in `agent-os/standards/` (not in subfolders)
+- **Root file** -- `root/naming` injects `agent-os/standards/naming.md`
+- Multiple arguments inject multiple standards
+
+## Process
+
+### Step 1: Detect Context Scenario
+
+Determine which scenario applies:
+
+1. **Conversation** -- Regular chat, implementing code, answering questions
+2. **Creating a Skill** -- Building a reusable procedure or skill file
+3. **Shaping/Planning** -- Building a spec, planning significant work
+
+If the scenario is not clearly one of these, ask the user to confirm.
+
+### Step 2: Read the Index (Auto-Suggest Mode)
+
+Read `agent-os/standards/index.yml` to get the list of available standards and their descriptions.
+
+If index.yml does not exist or is empty, advise the user to run discover-standards first, or index-standards if they have standards files without an index.
+
+### Step 3: Analyze Work Context
+
+Look at the current conversation to understand:
+- What type of work? (API, database, UI, etc.)
+- What technologies mentioned?
+- What is the goal?
+
+### Step 4: Match and Suggest
+
+Match index descriptions against the context. Present 2-5 relevant standards and ask the user to confirm.
+
+### Step 5: Inject Based on Scenario
+
+#### Scenario: Conversation
+Read the standards and present them directly with the full content of each standard file, followed by a summary of key points.
+
+#### Scenario: Creating a Skill
+Ask whether to include standards as file references or full content copy:
+- **References** -- Add file paths that point to the standards (lightweight, stays in sync)
+- **Copy content** -- Paste the full standards content (self-contained, does not update if standards change)
+
+#### Scenario: Shaping/Planning
+Same choice as Creating a Skill -- references or full content copy.
+
+### Step 6: Surface Related Skills (Conversation scenario only)
+
+When in conversation scenario, check if related skills exist and surface them for awareness. Do not invoke skills automatically.
+
+## Explicit Mode
+
+When arguments are provided, skip the suggestion step but still detect scenario.
+
+1. Parse arguments (folder names, folder/file paths, or root keyword)
+2. Validate that specified files/folders exist
+3. If not found, show available standards and suggest alternatives
+4. Inject based on detected scenario
+
+## Tips
+
+- **Run early** -- Inject standards at the start of a task, before implementation
+- **Be specific** -- If you know which standards apply, use explicit mode
+- **Check the index** -- If suggestions seem wrong, rebuild the index
+- **Keep standards concise** -- Injected standards consume tokens; shorter is better
+
+## Integration
+
+This command is called internally by shape-spec to inject relevant standards during planning. You can also invoke it directly anytime you need standards in context.
diff --git a/plugins/agent-os/prompts/fw.agent_os.plan_product.md b/plugins/agent-os/prompts/fw.agent_os.plan_product.md
new file mode 100644
index 00000000..4410f145
--- /dev/null
+++ b/plugins/agent-os/prompts/fw.agent_os.plan_product.md
@@ -0,0 +1,102 @@
+# Plan Product
+
+Establish foundational product documentation through an interactive conversation. Creates mission, roadmap, and tech stack files in `agent-os/product/`.
+
+## Guidelines
+
+- **Keep it lightweight** -- gather enough to create useful docs without over-documenting
+- **One question at a time** -- do not overwhelm with multiple questions
+
+## Process
+
+### Step 1: Check for Existing Product Docs
+
+Check if `agent-os/product/` exists and contains any of these files:
+- `mission.md`
+- `roadmap.md`
+- `tech-stack.md`
+
+If files exist, ask the user whether to start fresh, update specific files, or cancel.
+
+If no files exist, proceed to Step 2.
+
+### Step 2: Gather Product Vision (for mission.md)
+
+Ask the user three questions, one at a time:
+1. **What problem does this product solve?** -- The core problem or pain point
+2. **Who is this product for?** -- Target users or audience
+3. **What makes your solution unique?** -- Key differentiator or approach
+
+### Step 3: Gather Roadmap (for roadmap.md)
+
+Ask two questions, one at a time:
+1. **What are the must-have features for launch (MVP)?** -- Core features for the first usable version
+2. **What features are planned for after launch?** -- Future phases, or "none yet"
+
+### Step 4: Establish Tech Stack (for tech-stack.md)
+
+First, check if `agent-os/standards/global/tech-stack.md` exists.
+
+If the tech-stack standard exists, summarize it and ask if this project uses the same stack or differs.
+
+If no tech-stack standard exists (or the project differs), ask:
+- Frontend (e.g., React, Vue, vanilla JS, or N/A)
+- Backend (e.g., Rails, Node, Django, or N/A)
+- Database (e.g., PostgreSQL, MongoDB, or N/A)
+- Other (hosting, APIs, tools, etc.)
+
+### Step 5: Generate Files
+
+Create the `agent-os/product/` directory if it does not exist.
+
+#### mission.md
+```markdown
+# Product Mission
+
+## Problem
+[What problem this product solves]
+
+## Target Users
+[Who this product is for]
+
+## Solution
+[What makes the solution unique]
+```
+
+#### roadmap.md
+```markdown
+# Product Roadmap
+
+## Phase 1: MVP
+[Must-have features for launch]
+
+## Phase 2: Post-Launch
+[Planned future features, or "To be determined"]
+```
+
+#### tech-stack.md
+```markdown
+# Tech Stack
+
+## Frontend
+[Frontend technologies, or "N/A"]
+
+## Backend
+[Backend technologies, or "N/A"]
+
+## Database
+[Database choice, or "N/A"]
+
+## Other
+[Other tools, hosting, services]
+```
+
+### Step 6: Confirm Completion
+
+Report which files were created and remind the user they can edit them directly or run plan-product again to update.
+
+## Tips
+
+- If the user provides very brief answers, that is fine -- the docs can be expanded later
+- If they want to skip a section, create the file with a placeholder like "To be defined"
+- The shape-spec command reads these files when planning features, so having them populated helps with context
diff --git a/plugins/agent-os/prompts/fw.agent_os.reference.md b/plugins/agent-os/prompts/fw.agent_os.reference.md
new file mode 100644
index 00000000..fc45aebc
--- /dev/null
+++ b/plugins/agent-os/prompts/fw.agent_os.reference.md
@@ -0,0 +1,106 @@
+# Agent OS Reference
+
+Agent OS is a standards discovery, extraction, and deployment system for AI-assisted development. It keeps agents aligned with project coding conventions by maintaining a structured set of standards documents.
+
+## Core Concepts
+
+### Standards
+Standards are concise documents that capture coding patterns, conventions, and tribal knowledge from a codebase. They are stored in `agent-os/standards/[folder]/[standard].md` and indexed in `agent-os/standards/index.yml`.
+
+Standards should be:
+- **Concise** -- Every word costs tokens when injected into context
+- **Scannable** -- Bullet points over paragraphs
+- **Example-driven** -- Show, do not tell
+- **Single-concept** -- One standard per pattern
+
+### Standards Index
+The file `agent-os/standards/index.yml` maps each standard to a one-line description for quick matching. Format:
+
+```yaml
+folder-name:
+  file-name:
+    description: Brief description here
+```
+
+Alphabetized by folder, then by filename.
+
+### Product Documentation
+Product-level context is stored in `agent-os/product/`:
+- `mission.md` -- Problem, target users, solution
+- `roadmap.md` -- MVP and post-launch features
+- `tech-stack.md` -- Frontend, backend, database, and other tools
+
+### Specs
+Feature specifications are stored in `agent-os/specs/` using timestamped folders:
+```
+agent-os/specs/YYYY-MM-DD-HHMM-feature-slug/
+  plan.md
+  shape.md
+  standards.md
+  references.md
+  visuals/
+```
+
+## Available Commands
+
+### discover-standards
+Extract tribal knowledge from the codebase into documented standards. Analyzes code patterns, asks clarifying questions, and produces concise standard files.
+
+### inject-standards
+Inject relevant standards into the current context. Supports auto-suggest mode (analyzes context) and explicit mode (specify standards by path). Adapts output format based on whether you are in conversation, creating a skill, or shaping a plan.
+
+### index-standards
+Rebuild the standards index file. Scans for new files, removes stale entries, and maintains alphabetical order.
+
+### plan-product
+Establish foundational product documentation (mission, roadmap, tech stack) through interactive conversation.
+
+### shape-spec
+Structure planning for significant work. Gathers context, surfaces relevant standards, identifies reference implementations, and produces a spec folder with all planning artifacts.
+
+## Directory Structure
+
+```
+agent-os/
+  standards/
+    index.yml
+    api/
+      response-format.md
+      error-handling.md
+    database/
+      migrations.md
+    global/
+      tech-stack.md
+      naming.md
+  product/
+    mission.md
+    roadmap.md
+    tech-stack.md
+  specs/
+    2026-01-15-1430-user-comment-system/
+      plan.md
+      shape.md
+      standards.md
+      references.md
+      visuals/
+```
+
+## Configuration
+
+Agent OS uses a profile-based configuration system:
+
+```yaml
+version: 3.0
+default_profile: default
+```
+
+Profiles can inherit from other profiles and contain global standards (like tech-stack) that apply across all areas.
+
+## Writing Good Standards
+
+1. **Lead with the rule** -- State what to do first, explain why second
+2. **Use code examples** -- A code block is worth a thousand words
+3. **Skip the obvious** -- Do not document what the code makes clear
+4. **One standard per concept** -- Keep them focused
+5. **Bullet points over paragraphs** -- Scannable beats readable
+6. **Keep descriptions short** -- Index descriptions are one sentence
diff --git a/plugins/agent-os/prompts/fw.agent_os.shape_spec.md b/plugins/agent-os/prompts/fw.agent_os.shape_spec.md
new file mode 100644
index 00000000..a0420d27
--- /dev/null
+++ b/plugins/agent-os/prompts/fw.agent_os.shape_spec.md
@@ -0,0 +1,148 @@
+# Shape Spec
+
+Gather context and structure planning for significant work. Use this when starting a substantial feature or change.
+
+## Guidelines
+
+- **Offer suggestions** -- Present options the user can confirm, adjust, or correct
+- **Keep it lightweight** -- This is shaping, not exhaustive documentation
+
+## Process
+
+### Step 1: Clarify What We Are Building
+
+Ask the user to describe the feature or change. Based on their response, ask 1-2 clarifying questions if the scope is unclear:
+- "Is this a new feature or a change to existing functionality?"
+- "What is the expected outcome when this is done?"
+- "Are there any constraints or requirements I should know about?"
+
+### Step 2: Gather Visuals
+
+Ask if the user has any visuals to reference:
+- Mockups or wireframes
+- Screenshots of similar features
+- Examples from other apps
+
+If visuals are provided, note them for inclusion in the spec folder.
+
+### Step 3: Identify Reference Implementations
+
+Ask if there is similar code in the codebase to reference:
+- "The comments feature is similar to what we are building"
+- "Look at how src/features/notifications/ handles real-time updates"
+- "No existing references"
+
+If references are provided, read and analyze them to inform the plan.
+
+### Step 4: Check Product Context
+
+Check if `agent-os/product/` exists and contains files.
+
+If it exists, read key files (`mission.md`, `roadmap.md`, `tech-stack.md`) and ask if this feature should align with any specific product goals or constraints.
+
+If no product folder exists, skip this step.
+
+### Step 5: Surface Relevant Standards
+
+Read `agent-os/standards/index.yml` to identify relevant standards based on the feature being built. Present matched standards and ask the user to confirm which to include.
+
+Read the confirmed standards files to include their content in the plan context.
+
+### Step 6: Generate Spec Folder Name
+
+Create a folder name using this format:
+```
+YYYY-MM-DD-HHMM-{feature-slug}/
+```
+
+Where:
+- Date/time is current timestamp
+- Feature slug is derived from the feature description (lowercase, hyphens, max 40 chars)
+
+If `agent-os/specs/` does not exist, create it when saving the spec folder.
+
+### Step 7: Structure the Plan
+
+Build the plan with **Task 1 always being "Save spec documentation"**.
+
+Present this structure to the user:
+
+- **Task 1: Save Spec Documentation** -- Create `agent-os/specs/{folder-name}/` with:
+  - `plan.md` -- The full plan
+  - `shape.md` -- Shaping notes (scope, decisions, context)
+  - `standards.md` -- Relevant standards that apply to this work
+  - `references.md` -- Pointers to reference implementations studied
+  - `visuals/` -- Any mockups or screenshots provided
+- **Task 2+:** Implementation tasks based on the feature
+
+### Step 8: Complete the Plan
+
+After Task 1 is confirmed, build out remaining implementation tasks based on:
+- The feature scope from Step 1
+- Patterns from reference implementations (Step 3)
+- Constraints from standards (Step 5)
+
+Each task should be specific and actionable.
+
+### Step 9: Ready for Execution
+
+When the full plan is ready, confirm with the user:
+1. Task 1 saves all spec documentation first
+2. Then implementation tasks proceed
+
+## Output Structure
+
+```
+agent-os/specs/{YYYY-MM-DD-HHMM-feature-slug}/
+  plan.md           # The full plan
+  shape.md          # Shaping decisions and context
+  standards.md      # Which standards apply and key points
+  references.md     # Pointers to similar code
+  visuals/          # Mockups, screenshots (if any)
+```
+
+## shape.md Content
+
+```markdown
+# {Feature Name} -- Shaping Notes
+
+## Scope
+[What we are building]
+
+## Decisions
+- [Key decisions made during shaping]
+- [Constraints or requirements noted]
+
+## Context
+- **Visuals:** [List of visuals provided, or "None"]
+- **References:** [Code references studied]
+- **Product alignment:** [Notes from product context, or "N/A"]
+
+## Standards Applied
+- api/response-format -- [why it applies]
+- api/error-handling -- [why it applies]
+```
+
+## standards.md Content
+
+Include the full content of each relevant standard, organized with headers.
+
+## references.md Content
+
+```markdown
+# References for {Feature Name}
+
+## Similar Implementations
+
+### {Reference 1 name}
+- **Location:** `src/features/comments/`
+- **Relevance:** [Why this is relevant]
+- **Key patterns:** [What to borrow from this]
+```
+
+## Tips
+
+- **Keep shaping fast** -- Do not over-document. Capture enough to start, refine as you build.
+- **Visuals are optional** -- Not every feature needs mockups.
+- **Standards guide, not dictate** -- They inform the plan but are not always mandatory.
+- **Specs are discoverable** -- Months later, someone can find this spec and understand what was built and why.
diff --git a/plugins/agent-os/standards_discoverer/agent.yaml b/plugins/agent-os/standards_discoverer/agent.yaml
new file mode 100644
index 00000000..ff07794b
--- /dev/null
+++ b/plugins/agent-os/standards_discoverer/agent.yaml
@@ -0,0 +1,6 @@
+title: Standards Discoverer
+description: Discovers, extracts, and documents coding standards and conventions from existing codebases. Analyzes code patterns to produce concise, scannable standards that keep AI agents aligned with project conventions.
+context: You are a Standards Discoverer agent. Your specialty is analyzing codebases
+  to extract tribal knowledge, coding patterns, and conventions that are not obvious
+  from the code alone. You produce concise, well-structured standards documents that
+  AI agents and developers can reference to stay aligned with project norms.
diff --git a/plugins/agent-os/standards_discoverer/prompts/agent.system.standards_discoverer.md b/plugins/agent-os/standards_discoverer/prompts/agent.system.standards_discoverer.md
new file mode 100644
index 00000000..5916ca7b
--- /dev/null
+++ b/plugins/agent-os/standards_discoverer/prompts/agent.system.standards_discoverer.md
@@ -0,0 +1,50 @@
+You are the Standards Discoverer agent.
+
+Your purpose is to analyze codebases and extract tribal knowledge into concise, documented standards. You find patterns that are unusual, opinionated, tribal, or consistently applied -- and turn them into scannable reference documents that AI agents and developers can use.
+
+## Core Methodology
+
+### What You Look For
+- **Unusual or unconventional patterns** -- Not standard framework/library patterns
+- **Opinionated choices** -- Specific decisions that could have gone differently
+- **Tribal knowledge** -- Things a new developer would not know without being told
+- **Consistent patterns** -- Patterns repeated across multiple files
+
+### How You Work
+1. Analyze the codebase structure (folders, file types, patterns)
+2. Identify major areas (frontend, backend, database, cross-cutting)
+3. Read representative files in each area (5-10 per area)
+4. Present findings and let the user select what to document
+5. For each selected standard, ask clarifying questions about the "why"
+6. Draft concise standards and confirm before creating files
+7. Maintain an index of all standards for discoverability
+
+### Writing Standards
+Standards are injected into AI context windows. Every word costs tokens. Follow these rules:
+
+- **Lead with the rule** -- State what to do first, explain why second (if needed)
+- **Use code examples** -- Show, do not tell
+- **Skip the obvious** -- Do not document what the code already makes clear
+- **One standard per concept** -- Do not combine unrelated patterns
+- **Bullet points over paragraphs** -- Scannable beats readable
+
+### Standards Organization
+Standards are stored in `agent-os/standards/[folder]/[standard].md` with an index at `agent-os/standards/index.yml`.
+
+Folder examples: `api/`, `database/`, `javascript/`, `css/`, `backend/`, `testing/`, `global/`
+
+### Index Format
+```yaml
+folder-name:
+  file-name:
+    description: Brief description here
+```
+
+Alphabetize folders. Alphabetize files within each folder. One-line descriptions only.
+
+## Integration
+You work alongside other Agent OS capabilities:
+- **Inject Standards** -- Deploys relevant standards into working context
+- **Index Standards** -- Rebuilds the standards index
+- **Plan Product** -- Establishes product-level documentation
+- **Shape Spec** -- Structures planning for significant work using standards