Tooling: Scaling Agent Primitives

You’ve mastered the three-layer framework and understand that your Agent Primitives are executable software written in natural language. Now comes the natural next question: how do these markdown files scale beyond your individual development workflow?

The answer mirrors every programming ecosystem’s evolution. Just as JavaScript grew from browser scripts to need Node.js runtimes, package managers, and deployment tooling, your Agent Primitives need similar infrastructure to reach their full potential.

Natural Language as Code

Your Agent Primitives exhibit all the characteristics of professional software: modularity, reusability, dependencies, versioning, and continuous evolution. This isn’t just a metaphor - these .prompt.md and .instructions.md files represent a genuine new form of software development that deserves proper tooling infrastructure.

Consider what happens as your Agent Primitives mature:

  • Modularity: Separate concerns across different primitive files that work together
  • Reusability: Same primitives work reliably across projects and contexts
  • Dependencies: MCP servers, external tools, and context requirements that must be managed
  • Evolution: Continuous refinement and versioning as your workflows improve
  • Distribution: Teams want to share proven primitives like they share code libraries

This recognition transforms how we think about AI development tooling. Your natural language programs need the same infrastructure support as any other software.

Agent CLI Runtimes

Most developers create and run Agent Primitives directly in VS Code with GitHub Copilot - and that’s perfect for interactive development, debugging, and daily workflow refinement. But just as JavaScript eventually needed Node.js to break free from browser constraints, your natural language programs need Agent CLI Runtimes for automated and production scenarios.

The emerging ecosystem includes different vendor implementations of the same core functionality: OpenAI Codex CLI, Anthropic Claude Code, Google Gemini CLI, and future vendor runtimes as the ecosystem matures. Each provides command-line execution of your Agent Primitives with access to their respective model capabilities.

Inner Loop vs Outer Loop

The key insight is understanding when each environment serves you best:

  • Inner Loop (VS Code + GitHub Copilot): Interactive development, testing, and workflow refinement
  • Outer Loop (Agent CLI Runtimes): Reproducible execution, CI/CD integration, and production deployment

Agent CLI Runtimes transform your Agent Primitives from IDE-bound files into autonomously executable workflows that run consistently across any environment. They provide command-line execution, CI/CD integration, environment consistency, and native support for MCP servers - bridging your development work to production reality.

Runtime Management

While VS Code + GitHub Copilot handles individual development perfectly, teams need additional infrastructure for sharing, versioning, and productizing their Agent Primitives. Managing multiple CLI environments becomes complex quickly - different installation procedures, configuration requirements, and compatibility matrices.

AWD CLI solves this by providing unified runtime management and package distribution. Instead of manually installing and configuring each vendor CLI, AWD handles the complexity while preserving your existing VS Code workflow.

Here’s how runtime management works in practice:

# Install AWD CLI once
curl -sSL https://raw.githubusercontent.com/danielmeppiel/awd-cli/main/install.sh | sh

# AWD manages runtime installation for you
awd runtime setup codex          # Installs OpenAI Codex CLI
awd runtime setup llm            # Installs Simon Willison's LLM

# Check what's available
awd runtime list                 # Shows installed runtimes
awd runtime status               # Shows which runtime will be used

# Run workflows
awd run security-review --param pr=123

The key benefits become immediately apparent: your daily development stays exactly the same in VS Code, AWD installs and configures runtimes automatically, your workflows run regardless of which runtime is installed, and the same awd run command works consistently across all runtimes.

✅ Checkpoint: Runtime complexity is abstracted away while preserving development workflow flexibility

Distribution and Packaging

Once your Agent Primitives prove valuable, you’ll naturally want to share them with your team and eventually deploy them in production. This is where the parallels to traditional software development become most apparent - you need package management, dependency resolution, version control, and distribution mechanisms.

The challenge emerges quickly: you’ve built powerful Agent Primitives in VS Code, your team wants to use them, but distributing markdown files and ensuring consistent MCP dependencies across different environments becomes unwieldy. You need the equivalent of npm for natural language programs.

AWD CLI provides this missing layer. It doesn’t replace your VS Code workflow - it extends it by creating distributable packages of Agent Primitives complete with dependencies, configuration, and runtime compatibility that teams can share like npm packages.

Package Management in Practice

# Initialize new AWD project (like npm init)
awd init security-review-workflow

# Install MCP dependencies (like npm install)
cd security-review-workflow && awd install

# Develop and test your workflow locally
awd run start --param pr=123

# Package for distribution (future: awd publish)
# Share awd.yml and .prompt.md files with team

# Team members can install and use
git clone your-workflow-repo
cd your-workflow-repo && awd install
awd run start --param pr=456  # Works with their installed runtime

The benefits compound quickly: distribute tested workflows as versioned packages with dependencies, automatically resolve and install required MCP servers, track workflow evolution and maintain compatibility across updates, build on shared primitive libraries from the community, and ensure consistent execution across different team members’ setups.

Project Configuration

The awd.yml configuration file serves as the package.json equivalent for Agent Primitives, defining scripts, dependencies, and input parameters:

# awd.yml - Project configuration (like package.json)
name: security-review-workflow
version: 1.2.0
description: Comprehensive security review process with GitHub integration

scripts:
  start: "codex security-review.prompt.md"
  claude: "claude security-review.prompt.md"
  debug: "RUST_LOG=debug codex security-review.prompt.md"
  
dependencies:
  mcp:
    - ghcr.io/github/github-mcp-server
    - registry.npmjs.org/security-scanner-mcp
    
input:
  - pr_number
  - severity_level
  - review_depth

✅ Checkpoint: Your Agent Primitives are now packaged as distributable software with managed dependencies

Production Deployment

The final piece of the tooling ecosystem enables Continuous AI - automated execution of packaged Agent Primitives in production environments. Your carefully developed workflows can now run automatically in CI/CD pipelines with the same reliability as traditional software deployments.

Building on the security-review-workflow package example above, here’s how the same AWD project deploys to production with multi-runtime flexibility:

# .github/workflows/security-review.yml
name: AI Security Review Pipeline
on: 
  pull_request:
    types: [opened, synchronize]

jobs:
  security-analysis:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        script: [start, claude, debug]  # Maps to awd.yml scripts
    permissions:
      models: read
      pull-requests: write
      contents: read
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Run Security Review ($)
      uses: danielmeppiel/action-awd-cli@v1
      with:
        script: $
        parameters: |
          {
            "pr_number": "$",
            "severity_level": "high",
            "review_depth": "comprehensive"
          }
      env:
        GITHUB_TOKEN: $

Key Connection: The matrix.script values (start, claude, debug) correspond exactly to the scripts defined in the awd.yml configuration above. AWD CLI automatically installs the MCP dependencies (ghcr.io/github/github-mcp-server, security-scanner-mcp) and passes the input parameters (pr_number, severity_level, review_depth) to your security-review.prompt.md workflow.

This creates production-ready AI workflows with runtime flexibility, parallel execution capabilities, consistent deployment across environments, and automated quality processes integrated into standard CI/CD pipelines.

✅ Checkpoint: Your Agent Primitives now run automatically in production with the same reliability as traditional software

Ecosystem Evolution

This tooling progression follows the same predictable pattern as every successful programming ecosystem. Understanding this pattern helps you see where AI Native Development is heading and how to position your work strategically.

The evolution happens in four stages:

  1. Raw Code → Agent Primitives (.prompt.md, .instructions.md files)
  2. Runtime Environments → Agent CLI Runtimes (Codex CLI, Claude Code, etc.)
  3. Package Management → AWD CLI (distribution and orchestration layer)
  4. Thriving Ecosystem → Shared libraries, tools, and community packages

Just as npm enabled JavaScript’s explosive growth by solving the package distribution problem, AWD CLI enables the Agent Primitive ecosystem to flourish by providing the missing infrastructure layer that makes sharing and scaling natural language programs practical.

Key Takeaways

  1. Agent Primitives are Software: Your .prompt.md and .instructions.md files represent executable natural language programs that deserve professional tooling infrastructure
  2. Runtime Diversity Enables Scale: Agent CLI Runtimes (Codex CLI, Claude Code, Gemini CLI) provide the execution environments that bridge development to production
  3. Package Management is Critical: AWD CLI provides the npm-equivalent layer that makes Agent Primitives truly portable and shareable
  4. Production Ready Today: This tooling stack enables automated AI workflows in CI/CD pipelines with enterprise-grade reliability
  5. Ecosystem Growth Pattern: Package management infrastructure creates the foundation for thriving ecosystems of shared workflows, tools, and community libraries

The transformation is profound: what started as individual markdown files in your editor becomes a systematic software development practice with proper tooling, distribution, and production deployment capabilities.

Ready to build your first Agent Primitives? Continue to Getting Started to implement the foundational workflows that this tooling infrastructure supports.

Want to see advanced execution patterns? Jump to Agent Delegation for comprehensive orchestration strategies that leverage this tooling foundation for both local and async agent coordination.