AGENTS.md Template for Static Asset Delivery Architecture

Overview

AGENTS.md Template for static asset delivery architecture defines a project-level operating manual for single-agent and multi-agent workflows that coordinate planning, implementation, review, testing, and handoffs to ensure fast, reliable, and secure delivery of static assets via origin servers and CDNs.

When to Use This AGENTS.md Template

• Designing a new static asset delivery pipeline across origin and edge delivery
• Coordinating multiple AI agents for planning, implementation, review, testing, and security
• Establishing handoff rules, memory, and source-of-truth across the workflow
• Enforcing tool governance and secret management for assets and credentials
• Ensuring auditable deployment and rollback of asset configurations

Copyable AGENTS.md Template

# AGENTS.md

Project: Static Asset Delivery Architecture

Project role: Orchestrate and implement automated delivery of static assets via origin and CDN with multi-agent collaboration.

Agent roster and responsibilities:
  - PlannerAgent: defines goals, scope, milestones, and memory; generates task specs for agents.
  - ImplementerAgent: applies asset deployment, CDN rules, cache settings, versioning, and invalidations.
  - ReviewerAgent: validates configurations, policies, compliance, and error budgets.
  - TesterAgent: runs end-to-end tests, performance budgets, and monitors delivery quality.
  - ResearcherAgent: CDN edge specialist providing constraints, latency targets, and best practices.
  - SecurityAgent: ensures secrets management, access control, and secure workflows.
Supervisor or orchestrator behavior:
  - Orchestrator coordinates task assignment, enforces timing, and maintains a canonical memory snapshot.

Handoff rules between agents:
  - Planner to Implementer: hand off task specs and memory references.
  - Implementer to Reviewer: deliver asset manifests, CDN configs, and validation logs.
  - Reviewer to Tester: provide test plan and acceptance criteria.
  - Tester to Orchestrator: report results and decisions.
  - Orchestrator to Planner: trigger next cycle or escalate.

Context, memory, and source-of-truth rules:
  - All decisions are stored in a shared memory store with explicit sources of truth.
  - Memory is versioned and referenced by task IDs.

Tool access and permission rules:
  - Agents may access origin storage, CDN APIs, and deployment tooling only through approved interfaces.
  - Secrets are retrieved from a vault; no plaintext secrets in logs or memory.

Architecture rules:
  - Event-driven, idempotent, auditable actions with deterministic outputs.
  - All actions are reversible via defined rollback steps.

File structure rules:
  - Only necessary folders are created: assets, configs, orchestrations, tests.
  - Do not introduce unused tech or files.

Data, API, or integration rules when relevant:
  - Use CDN APIs for cache control, origin pull, and path-based routing.
  - Asset versioning via hash-based file names; origin must provide integrity checks.

Validation rules:
  - All changes pass unit and integration checks; delivery meets latency and error budgets.

Security rules:
  - Secrets in vault, rotate keys, least-privilege access.

Testing rules:
  - End-to-end tests, cache hit/miss tests, invalidation tests, and rollback tests.

Deployment rules:
  - Canary deploys, blue/green where feasible, with rollback and monitoring.

Human review and escalation rules:
  - Any security or production-impacting changes require human review and approval.

Failure handling and rollback rules:
  - If deployment fails, trigger rollback to last good state and alert owner.

Things Agents must not do:
  - Do not expose credentials; do not perform production changes without approval; do not bypass tests.

Recommended Agent Operating Model

Planner guides the overall objective and decides when to involve Implementer, Reviewer, Tester, and Security agents. Implementers execute configurations for origin and CDN. Reviewers verify policy conformance. Testers validate delivery latency and correctness. Researchers provide domain knowledge about CDN constraints. Security ensures secrets and access controls. Handoffs are explicit and memory-backed with a single orchestrator coordinating actions and escalations.

Recommended Project Structure

project-root/
  assets/
    origin/
    cdn/
  configs/
  orchestrations/
    static-asset-delivery/
      planners/
      implementers/
      reviewers/
      testers/
      researchers/
      security/
  tests/

Core Operating Principles

• Clear ownership and explicit handoffs between agents.
• Idempotent actions with auditable state and memory.
• Tool governance and secret management by design.
• Deterministic decisions with sources of truth.
• Immediate escalation for security or production-impacting changes.
• Security-by-default and least-privilege access.

Agent Handoff and Collaboration Rules

Define when planner hands off to implementer, how results are validated by reviewers, and how testers verify quality. Use explicit memory references and ensure traceability across cycles.

Tool Governance and Permission Rules

Only approved interfaces may be used for asset deployment, CDN control, and secret access. All actions require authorisation and are auditable. Secrets never appear in logs.

Code Construction Rules

Write idempotent deployment scripts, use versioned artifacts, and apply consistent logging and error handling. Avoid hard-coded secrets and ensure reproducible builds.

Security and Production Rules

Rotate credentials regularly, apply least-privilege, and enforce access controls on all assets and APIs. Production changes require approvals and monitoring with rollback paths.

Testing Checklist

• Unit tests for individual agents
• Integration tests for asset delivery pipeline
• End-to-end tests for cache invalidation and delivery latency
• Deployment and rollback tests

Common Mistakes to Avoid

• Skipping memory/session handling across agents
• Overly leaky abstractions that break auditability
• Bypassing reviews or secret vaults
• Unclear handoffs leading to duplicated work

Related implementation resources: AI Use Case for Corporate Event Managers Using Slack To Orchestrate Day-Of Venue Tasks Across Multi-Department Teams and AI Use Case for Gym Franchises Using Excel To Analyze Membership Peak Check-In Times and Adjust Staffing Levels.

FAQ

What is this AGENTS.md Template for Static Asset Delivery Architecture?

It defines how AI coding agents coordinate across planning, implementation, review, testing, and security to deliver assets efficiently via CDN and origin with proper handoffs and governance.

Which agent roles are defined in this template?

Planner, Implementer, Reviewer, Tester, Researcher, Security, and an Orchestrator that coordinates handoffs and memory.

How is context and memory managed across agents?

All decisions and actions are stored in a shared memory store with explicit sources of truth and versioned references.

How are tools and secrets access controlled?

Access is role-based, secrets are stored in a vault, and all API calls are audited; no plaintext secrets in logs.

How are failures rolled back?

Failures trigger a rollback plan, revert changes, and notify stakeholders; steps are idempotent and reversible.