AGENTS.md Template for Manufacturing Operations Agents

Overview

Direct answer: This AGENTS.md template defines a manufacturing-operations AI coding agents workflow that supports both single-agent execution and multi-agent orchestration. It establishes a clear operating context, roles, and guardrails so agents can hand off work with memory, sources of truth, and tool governance in place.

The AGENTS.md template provides a comprehensive operating manual you can paste into a project as a living contract for agent behavior. It describes the agent roster, supervisor/orchestrator behavior, handoff rules, architecture constraints, and security requirements to run reliable automated manufacturing workflows.

When to Use This AGENTS.md Template

• When you need a repeatable, auditable manufacturing operations automation pattern with multi-agent coordination.
• When you require explicit handoffs between planner, implementer, reviewer, tester, researcher, and domain-specialist agents.
• When tool governance, memory, and source-of-truth must be enforced across a production environment.
• When you want a project-level operating context that prevents context drift and unsupervised production changes.

Copyable AGENTS.md Template

# AGENTS.md

Project Role: Manufacturing Operations Automation Agent Network

Agent Roster and Responsibilities:
- Planner: Defines objectives, coordinates tasks, and creates clear handoff payloads.
- Implementer (Automation Engine): Executes tasks via restricted tooling, updates memory, and validates outputs.
- Reviewer: Verifies correctness, security, and compliance before deployment to production.
- Tester: Performs unit and integration tests against defined acceptance criteria.
- Researcher: Gathers domain knowledge, references sources, and maintains up-to-date data models.
- Domain Specialist (Quality, Maintenance, or Supply Chain): Provides domain-specific decisions and validations.

Supervisor or Orchestrator Behavior:
- Maintains a single source of truth and a shared memory/state store.
- Coordinates plan creation, task assignment, and handoffs between agents.
- Enforces tool governance, secrets handling, and production controls.
- Triggers human review when risk thresholds are exceeded or non-deterministic outcomes occur.

Handoff Rules Between Agents:
- Context and memory are passed with a canonical payload.
- Handoffs are only performed at defined task boundaries and must include input, output, and acceptance criteria.
- The orchestrator logs handoffs for traceability and rollback if needed.

Context, Memory, and Source-of-Truth Rules:
- Memory is versioned and persisted in a centralized store accessible to all agents.
- All data and decisions reference a primary source-of-truth (e.g., MES/ERP data, sensor streams).
- Agents must cite sources in outputs and avoid fabrications.

Tool Access and Permission Rules:
- Agents use ephemeral tokens with scoped permissions.
- Only approved tools and APIs are callable; all actions are auditable.
- Secrets are never hard-coded; access requires approval gates.

Architecture Rules:
- Use event-driven patterns with a central orchestrator and agent microservices.
- Prefer idempotent actions and stateless planners where possible.
- Logging and auditing are mandatory for all actions.

File Structure Rules:
- Keep all artifacts under a single project root with clear subfolders for agents, memory, data, and integrations.
- Do not duplicate code; reuse templates and helper modules.

Data, API, or Integration Rules:
- All external data sources are validated and signed when applicable.
- API calls must follow defined schemas and error-handling strategies.

Validation Rules:
- All outputs must conform to predefined schemas and success criteria.
- Outputs should be deterministic given the same input payload.

Security Rules:
- Enforce least privilege on credentials and restricted secrets.
- Encrypt data in transit and at rest; logs must not reveal secrets.

Testing Rules:
- Include unit tests for individual agents and integration tests for handoffs.
- Tests must cover success, failure, and edge cases, with deterministic results.

Deployment Rules:
- Deploy changes through a controlled pipeline with review gates.
- Roll back on failed deployments with preserving last good state.

Human Review and Escalation Rules:
- Escalate to human in cases of high risk, ambiguity, or inconsistent data signals.
- Provide a clear escalation path and time-bound resolution targets.

Failure Handling and Rollback Rules:
- On failure, revert to last known-good state and re-run with adjusted inputs where appropriate.
- Log all failure signals and root causes for continuous improvement.

Things Agents Must Not Do:
- Do not bypass approval gates or access production systems without a gate pass.
- Do not rely on stale memory; always re-validate sources before acting.
- Do not perform actions outside the defined workflow or outside permitted services.

Recommended Agent Operating Model

The operating model assigns clear roles and decision boundaries for a manufacturing-ops workflow. Planners decide what to do and when to hand off; Implementers execute with tight control; Reviewers audit, testers validate, Researchers augment domain knowledge, and Domain Specialists approve critical decisions. Escalation paths ensure human review when quality or safety risk is detected.

Recommended Project Structure

manufacturing-ops-project/
├── agents/
│   ├── planner/
│   ├── implementer/
│   ├── reviewer/
│   ├── tester/
│   ├── researcher/
│   └── domain-specialist/
├── memory/
├── data/
├── integrations/
├── configs/
└── workflows/
    └── manufacturing-ops/

Core Operating Principles

• Single source of truth and traceable memory.
• Deterministic handoffs with explicit acceptance criteria.
• Strict tool governance and permission-scoped actions.
• Self-checks and human-in-the-loop when risk is detected.
• Idempotent, auditable, and testable agent actions.

Agent Handoff and Collaboration Rules

• Planner to Implementer: pass objective, input data, acceptance criteria, and success metrics.
• Implementer to Reviewer: pass results, logs, schemas, and any exceptions.
• Reviewer to Implementer: request corrections or approve deployment-ready outputs.
• Researcher to Domain Specialist: provide domain context and validation references.
• Domain Specialist to Planner: supply decisions and constraints for next planning cycle.

Tool Governance and Permission Rules

• Only approved tools/APIs may be invoked; all actions are logged.
• Secrets are stored in a restricted vault and rotated per policy.
• Production actions require orchestration gates and human review if risk exceeds thresholds.
• Commands must be idempotent and auditable.

Code Construction Rules

• Follow the project’s code style guidelines; write small, composable functions.
• Validate all inputs against schemas before processing.
• Avoid duplicating logic; reuse shared utilities.
• Provide comprehensive logging and error handling.
• Document assumptions and maintainability considerations.

Security and Production Rules

• Implement role-based access control for all agents.
• Encrypt sensitive data in transit and at rest; audit trails are required.
• Escalate to human review for safety-critical operations or ambiguous data.

Testing Checklist

• Unit tests for each agent role.
• Integration tests for handoff sequences.
• End-to-end tests simulating production scenarios.
• Regression tests on memory and source-of-truth updates.

Common Mistakes to Avoid

• Assuming single-agent success without orchestration constraints.
• Over-sharing memory or bypassing verification steps.
• Using hard-coded secrets or non-idempotent operations.
• Ignoring domain-specific constraints during planning.

Related implementation resources: AI Use Case for Supply Chain Managers Using Slack To Receive Automatic Alerts When Inventory Dips Below Safety Stock Levels.

FAQ

What is this AGENTS.md Template used for in manufacturing operations?

This template defines a repeatable, auditable operating manual for AI coding agents coordinating manufacturing workflows with clear roles, handoffs, and governance.

How does multi-agent orchestration work with this template?

It defines an orchestrator that sequences planner, implementer, reviewer, tester, researcher, and domain-specialist actions with explicit handoffs and shared memory.

What are the handoff rules between agents?

Handoffs include input, output, acceptance criteria, and traceable context; the orchestrator enforces and logs transitions.

How is tool governance enforced?

Tools and APIs are restricted, secrets are rotated, and all actions are auditable with gated permissions.

How do I validate and deploy changes from this template?

Changes must pass unit/integration tests, undergo human review if needed, and be deployed through a controlled pipeline with rollback support.