AGENTS.md Template: Social Network System Design

Overview

The AGENTS.md template defines the operating context for AI coding agents managing a social network system design. It governs a workflow that supports both single-agent operation and multi-agent orchestration across planner, implementer, reviewer, tester, researcher, and domain specialist roles. It codifies guardrails, memory rules, source-of-truth references, and handoff protocols to keep work auditable and repeatable.

Direct answer style summary: This AGENTS.md template provides precise roles, boundaries, and handoffs to enable reliable, auditable AI-driven design of social network features through multi-agent orchestration.

When to Use This AGENTS.md Template

• When designing a social network system where multiple AI agents collaborate on architecture, data flows, and policy compliance.
• When you need explicit handoff rules between planner, implementer, reviewer, tester, researcher, and domain specialist roles.
• When enforcing tool governance, memory boundaries, and source-of-truth for repeatable design outcomes.
• When you require a copyable, project-level AGENTS.md to bootstrap new workflows quickly.

Copyable AGENTS.md Template

# AGENTS.md

Project role
- Lead Architect for Social Network System Design overseeing AI coding agents implementing a multi-agent workflow for social network features.

Agent roster and responsibilities
- Planner: defines architecture, milestones, and handoff criteria.
- Implementer: builds and wires components according to plan.
- Reviewer: verifies outputs against specs and policies.
- Tester: runs unit/integration tests and user-flow checks.
- Researcher: sources domain knowledge and ensures citations.
- Domain Specialist: ensures privacy, moderation constraints, and regulatory alignment.

Supervisor or orchestrator behavior
- The Orchestrator coordinates tasks, enforces memory and source-of-truth rules, and triggers human review when required.

Handoff rules between agents
- Planner to Implementer: deliver design spec, acceptance criteria, and code skeleton.
- Implementer to Reviewer: deliver build, test results, and notes.
- Reviewer to Implementer: deliver fixes and updated outputs.
- Researcher or Domain Specialist to any agent: provide sources, constraints, and policy guidance.

Context, memory, and source-of-truth rules
- Central memory store with keys: project_context, design_decisions, data_sources.
- All outputs must reference source-of-truth IDs or URLs.

Tool access and permission rules
- Tools allowed: Code Editor, Test Runner, API Explorer, Secrets Manager, Issue Tracker.
- No direct production system access without approvals.

Architecture rules
- Microservice oriented: feed-service, graph-service, moderation-service, auth-service.

File structure rules
- Place all agent definitions under agents/
- Place service definitions under services/
- Keep docs and configs under respective folders.

Data, API, or integration rules when relevant
- Use REST/GraphQL endpoints for services; define data contracts.

Validation rules
- Outputs must be deterministic, idempotent, and reproducible.

Security rules
- Secrets stored in vault; no plaintext tokens; rotate keys; least privilege.

Testing rules
- Unit tests per agent; integration tests for end-to-end flows; regression tests.

Deployment rules
- CI/CD gates; canary rollouts; rollback plans.

Human review and escalation rules
- Escalate uncertain decisions to human reviewer; document rationale.

Failure handling and rollback rules
- On failure, revert to last good state; log changes in an audit trail.

Things Agents must not do
- Do not reveal secrets, bypass authentication, modify production data outside scope, or perform unsupervised production changes.

Recommended Agent Operating Model

Roles and decision boundaries are defined to support a social network system design workflow where AI agents collaborate across architecture, data, and policy domains. Decisions by the Planner are binding for high-level design but must be validated by the Reviewer. Handoffs are explicit, auditable, and gated by automated checks and optional human review.

Recommended Project Structure

// Social Network Design Project Structure
ai-skills/ai-skills/agents-md-templates/social-network-design/
  agents/
    planner/
    implementer/
    reviewer/
    tester/
    researcher/
    domain-specialist/
  services/
    feed-service/
    graph-service/
    moderation-service/
    auth-service/
  data/
    schemas/
    sources/
  workflows/
  docs/
  configs/

Core Operating Principles

• Single source of truth for design decisions and data sources.
• Deterministic, idempotent agent outputs with clear audit trails.
• Explicit memory keys and bounded context per workflow.
• Guardrails, validation gates, and human-in-the-loop when needed.
• Composable, modular agent roles enabling scalable multi-agent orchestration.

Agent Handoff and Collaboration Rules

• Planner to Implementer: provide design spec, milestones, acceptance criteria, and interfaces.
• Implementer to Reviewer: deliver running code, architectural sketches, and test results.
• Reviewer to Implementer: provide fixes and updated artifacts with rationale.
• Researcher/Domain Specialist to all: supply sources, constraints, and policy guidance.
• All agents: respect memory keys and refer to source-of-truth IDs for outputs.

Tool Governance and Permission Rules

• Only approved tools may be used for code edits, tests, API calls, or secret access.
• Secrets must be retrieved from a secrets manager; do not hard-code tokens.
• Production interactions require gate approvals and audit logging.

Code Construction Rules

• Write modular, testable components with clear interfaces.
• Follow memory and data-source references; avoid data drift.
• Use deterministic algorithms for ranking and moderation decisions where possible.
• Document data contracts and API schemas alongside code.

Security and Production Rules

• Enforce least privilege; rotate credentials; monitor access patterns.
• Implement input validation, rate limiting, and robust error handling.
• Require human review for high-risk production changes or policy exceptions.

Testing Checklist

• Unit tests for each agent function and module.
• Integration tests across planner-implementer-reviewer cycles.
• End-to-end tests for social network workflows (feed, moderation, graph queries).
• Security and privacy tests; data minimization checks.
• Canary and rollback checks for deployment rules.

Common Mistakes to Avoid

• Ambiguity in handoff criteria or acceptance criteria.
• Uncontrolled data access or bypassing permissions.
• Non-idempotent actions in production guidance.
• Missing source-of-truth references in outputs.

Related implementation resources: AI Use Case for Social Media Comments and Lead Discovery and AI Use Case for Sales Pipeline Reviews and Deal Risk Scoring.

FAQ

What is this AGENTS.md Template for social network system design?

A complete operating manual for AI coding agents to govern social network architecture, data flows, and policy compliance using multi-agent orchestration.

Which agents are defined in this template and what are their duties?

Planner defines high-level architecture and milestones; Implementer builds components; Reviewer validates outputs; Tester ensures quality; Researcher gathers sources; Domain Specialist handles privacy and moderation constraints.

How are memory and source-of-truth managed?

All outputs are anchored to a central memory store with explicit keys and citations to source-of-truth IDs or URLs to ensure traceability.

How is security enforced?

Secrets use vaults and least-privilege access; no hard-coded credentials; production changes require approval gates and human review.

How do you validate and deploy changes?

Run unit/integration tests, verify acceptance criteria, stage changes, and maintain audit trails for rollbacks.