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.

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.