Templates — comanda

⊞ MCP: Release Notes#

Give any connected agent a versioned release-notes tool. It accepts a git diff as input and an audience as an MCP argument.

mcp git workflow

# Turn a git diff into release notes for {{ audience }}
release_notes:
  input: STDIN
  model: gpt-5.6-terra
  action: |
    Write {{ audience }} release notes from the supplied diff.
    Lead with impact, call out breaking changes, and do not invent work.
  output: STDOUT

# claude mcp add comanda -- comanda mcp --dir ./workflows

🛡️ MCP: Dependency Triage#

Let an agent hand package manifests or scanner output to a consistent, reviewable security workflow when it actually needs a risk decision.

mcp security dependencies

# Prioritize dependency risks for {{ environment }}
dependency_triage:
  input: STDIN
  model: claude-code
  action: |
    Assess the supplied dependency report for {{ environment }}.
    Rank actionable risks, explain impact, and propose the smallest safe fix.
  output: STDOUT

# The MCP tool schema exposes input and environment automatically.

🔀 Architecture Decision#

Get perspectives from Claude, Gemini, and Codex on architectural decisions, synthesized into a formal ADR.

multi-agent claude-code gemini-cli codex

parallel-process:
  claude-analysis:
    input: STDIN
    model: claude-code
    action: "Analyze options and trade-offs"
    output: ./results/claude-analysis.md

  gemini-analysis:
    input: STDIN
    model: gemini-cli
    action: "Industry best practices"
    output: ./results/gemini-analysis.md
...

✦ Kimi Code Agentic Loop#

Use the local Kimi Code CLI as a full agentic coding worker with scoped filesystem access and an explicit completion signal.

kimi-code agentic-loop tool-use

implement:
  agentic_loop:
    max_iterations: 5
    exit_condition: pattern_match
    exit_pattern: "DONE"
  input: STDIN
  model: kimi-code
  allowed_paths: [./src, ./tests]
  action: |
    Implement the requested change. Inspect existing code, edit files,
    and run relevant tests. Start your final response with DONE only
    when the change is complete and verified.
  output: STDOUT

📚 Build Durable Agent Context#

Turn a rich codebase index into maintainable agent documentation without repeatedly injecting an entire repository into every loop.

codebase-indexing agentic-loop documentation

# First: comanda index capture . -n myproject --enhance --max-files 10000
build_context:
  agentic_loop:
    max_iterations: 12
    exit_condition: llm_decides
  input: NA
  model: claude-code
  allowed_paths: [., ./docs]
  action: |
    Use .comanda/myproject_INDEX.md as a map. Read it and the source
    selectively; do not echo the index. Write or update AGENT_CONTEXT_*.md
    files covering architecture, conventions, workflows, and gotchas.
    End each iteration with a status under 500 characters. Say DONE only
    after creating AGENT_CONTEXT_INDEX.md.
  output: STDOUT

🛡️ Zero-Day Dependency Scanner#

Scan package.json, go.mod, requirements.txt for known CVEs using real-time OSV.dev API data. Works with any ecosystem.

security tool-use xai

parse-deps:
  input: STDIN
  model: grok-4-1-fast-non-reasoning
  action: "Extract deps as JSON array"
  output: ./deps.json

query-osv:
  input: ./deps.json
  model: NA
  tool_config:
    allowlist: [curl, jq]
  output: "tool: query OSV.dev API..."

generate-report:
  input: ./vulns.json
  model: grok-4-1-fast-non-reasoning
  action: "Generate CVE report with remediation"
  output: STDOUT

🧩 Skill: Summarize#

Built-in skill for summarizing documents. Invoke from CLI or use in workflows with skill_args.

skills bundled

# ~/.comanda/skills/summarize.md
---
description: "Summarize a document"
arguments:
  file:
    required: true
  format:
    default: "bullets"
---

Read ${file} and summarize in ${format} format.

# Usage:
# comanda skills run summarize --file README.md

🔗 Skills in Workflows#

Use skills as steps in larger workflows. Pass arguments, chain outputs, mix with other step types.

skills workflow

analyze-docs:
  skill: summarize
  skill_args:
    file: ./docs/API.md
    format: prose
  output: ./api-summary.md

review-summary:
  input: ./api-summary.md
  model: gpt-4o
  action: "Check for completeness"
  output: STDOUT

🔍 Code Review#

Comprehensive code review using Claude Code for bugs, security issues, and improvement suggestions.

claude-code code-quality

review:
  input: "src/*.go"
  model: claude-code
  action: |
    Review for:
    - Bugs and logic errors
    - Security vulnerabilities
    - Performance issues
    - Code style improvements
  output: review.md

🔄 Creator/Checker#

Two-loop pattern: creator implements features, checker validates. Auto-reruns on failure.

agentic-loop validation

loops:
  feature-creator:
    max_iterations: 3
    output_state: $CREATOR_RESULT
    steps:
      - implement:
          model: claude-code
          action: "Implement feature..."

  code-checker:
    depends_on: [feature-creator]
    input_state: $CREATOR_RESULT
    exit_pattern: "^(PASS|FAIL)"

📚 RAG Workflow#

Retrieval-augmented generation: search your docs with qmd, then answer questions with context.

rag qmd search

retrieve:
  type: qmd-search
  qmd_search:
    query: "${QUESTION:-STDIN}"
    collection: docs
    limit: 5
  output: CONTEXT

answer:
  input: "Context: ${CONTEXT}\nQuestion: ${QUESTION}"
  model: claude-sonnet

🔁 Iterative Refinement#

Agentic loop that iterates on code until it meets quality standards. LLM decides when complete.

agentic-loop code-generation

implement:
  agentic_loop:
    max_iterations: 3
    exit_condition: pattern_match
    exit_pattern: "SATISFIED"
  input: STDIN
  model: claude-code
  action: |
    Iteration {{ loop.iteration }}.
    Previous: {{ loop.previous_output }}
    
    Refine until production-ready.
  output: STDOUT

✅ Quality Gate#

Agentic loop with quality gates that abort or retry based on code quality checks.

agentic-loop quality-gate

generate:
  agentic_loop:
    max_iterations: 5
    exit_condition: quality_gate
    quality_command: "go test ./..."
    on_failure: retry
  input: STDIN
  model: claude-code
  action: "Implement with passing tests"
  output: STDOUT

⚖️ Model Comparison#

Run the same prompt through multiple models in parallel and compare their outputs.

parallel comparison

parallel-process:
  gpt:
    model: gpt-5.6-terra
    action: "Solve the problem"
    output: gpt4-result.txt
  claude:
    model: claude-code
    action: "Solve the problem"
    output: claude-result.txt

compare:
  input: [gpt4-result.txt, claude-result.txt]
  action: "Compare approaches"

📦 Batch Processing#

Process multiple files with wildcards. Choose individual or combined mode for safety.

data batch files

process-files:
  input: "examples/*.txt"
  model: gpt-4o
  action: "Summarize each file."
  output: STDOUT
  batch_mode: individual
  skip_errors: true

🧪 Generate Tests#

Automatically generate comprehensive test suites for your code using Claude Code.

claude-code testing

generate-tests:
  input: "src/api/*.go"
  model: claude-code
  action: |
    Generate comprehensive tests:
    - Unit tests for all functions
    - Edge cases and error handling
    - Table-driven tests where appropriate
    - Mock external dependencies
  output: src/api/*_test.go

🛠️ Tool Integration#

Execute shell commands within workflows. Perfect for git operations, linting, and build pipelines.

tool-use bash

get-changes:
  tool: bash
  input: "git diff HEAD~5 --stat"
  output: ./changes.txt

analyze:
  input: ./changes.txt
  model: claude-code
  action: "Summarize recent changes"
  output: STDOUT

🗂️ Code Indexing#

Index your codebase with qmd for semantic code search and retrieval.

qmd rag search

index:
  type: qmd-index
  qmd_index:
    path: ./src
    collection: my-codebase
    mask: "**/*.{go,ts,py}"
    embed: true

search:
  type: qmd-search
  qmd_search:
    query: "authentication logic"
    collection: my-codebase

🕸️ Dependency Graph#

Multiple loops with dependencies. Loops can depend on other loops completing first.

agentic-loop orchestration

loops:
  analyze:
    output_state: $ANALYSIS
    steps:
      - analyze: ...

  implement:
    depends_on: [analyze]
    input_state: $ANALYSIS
    output_state: $CODE

  test:
    depends_on: [implement]
    input_state: $CODE

🌐 Web Scraping#

Fetch and analyze web pages. Take screenshots and extract structured data.

web scraping

fetch:
  input: "https://example.com/docs"
  output: ./page-content.html

analyze:
  input: ./page-content.html
  model: gpt-5.6-terra
  action: |
    Extract key information:
    - Main topics covered
    - API endpoints mentioned
    - Code examples
  output: summary.md

📊 Data Analysis#

Analyze CSV files and structured data. Generate insights and visualizations.

data csv

analyze:
  input: quarterly_data.csv
  model: gpt-4o
  action: |
    Analyze this data:
    - Key trends and patterns
    - Notable outliers
    - Recommendations
  output: analysis.md

🔎 File Comparison#

Compare two files and get an intelligent summary of differences and similarities.

data compare

compare:
  input:
    - old-config.yaml
    - new-config.yaml
  model: claude-sonnet
  action: |
    Compare these two files:
    - What changed?
    - Are changes breaking?
    - Migration recommendations
  output: STDOUT

🏗️ Architecture Review#

Multi-agent review of system architecture from security, scalability, and maintainability perspectives.

multi-agent architecture

parallel-process:
  security-review:
    model: claude-code
    action: "Security analysis"
  scalability-review:
    model: gemini-cli
    action: "Scalability analysis"
  maintainability-review:
    model: codex
    action: "Maintainability analysis"

💾 Checkpoint & Resume#

Long-running workflows with checkpoints. Resume from where you left off after interruption.

agentic-loop checkpoint

loops:
  long-task:
    stateful: true
    checkpoint_interval: 1
    max_iterations: 10
    steps:
      - process:
          action: |
            Iteration {{ loop.iteration }}
            Previous: {{ loop.previous_output }}
            Continue processing...

Workflow Templates