Polymorphic AI Teams — Dynamic Team Topology for AI Agents

Founded on Conway's Law (1967): "Organizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations." Everything in this framework — the shapes, the roles, the communication rules — derives from this single law applied to AI agent teams.

A framework for structuring AI agent teams based on HR organizational design principles. The core insight: AI agent teams can dynamically restructure their organizational topology per project phase at zero cost — something human teams cannot do.

Full framework repo: ChinchillaEnterprises/polymorphic-ai-teams (private)

The One Law

Conway's Law: The architecture of the system you build will mirror the organizational structure of the team that builds it.

Therefore: design the org chart first. The architecture follows. Do not start coding before the org chart shape is determined.

Terminology (Roman Legion System)

Communication Rules

Commander  <->  Legate         (human interface)
Legate     <->  Tribune        (command relay)
Tribune    <->  All Centurions (vertical command)
Centurion  <->  Centurions     (lateral collaboration — SELECTIVE, not all-to-all)
Decurio    <->  Own Centuria   (isolated execution — NEVER cross-centuria)

• Centurions talk laterally — they are the nervous system. Their links become the product's API contracts.
• Decurios do NOT cross-communicate — keeps workers focused. Coordination happens one layer up.

The Decuria Mandate

The centurion layer is always mandatory. It is not optional. This forces the Architect to delegate work into properly sized teams rather than trying to handle everything with 2-3 agents.

Don't ask the AI to be a good manager — give it a structure that makes bad management structurally impossible.

The centurion layer is the invariant that enables polymorphism. Like Roman military units: standardized building blocks (centuries), polymorphic formations (testudo, wedge, orbis).

There must always be a centurion layer, but the number of centurions is polymorphic.

The Three Things That Morph

1. Number of centurions — grows/shrinks as the product matures
2. Mission of each centurion — changes per phase (vertical feature work → horizontal review → cross-cutting QA)
3. Lateral links between centurions — the Architect activates/deactivates channels per phase

The Shape Rule (CRITICAL)

Different products require different org chart SHAPES. Never use a template.

Before building any team, determine the product's data flow shape:

Phalanx (Chain / Sequential)

  1 → 2 → 3 → 4 → 5

• Use when: each stage consumes previous stage's output (ETL, CI/CD pipelines)
• Linear advance — each rank behind the last

Testudo (Star / Hub)

        2
       ╱
  1 ← 5 → 3
       ╲
        4

• Use when: one central capability serves all others (platform, marketplace, API gateway)
• Turtle formation — central hub shielded by all sides

Wedge (Funnel / Pipeline)

    1     2     3
     ╲    │    ╱
      ╲   │   ╱
          4
          │
          5

• Use when: many inputs converge to fewer outputs (analytics, reporting, internal tools)
• Architect position: top of funnel
• Example: fleet + routes + deliveries → analytics → dashboards
• V-formation — many inputs converging to a spearpoint

Orbis (Circle / Feedback Loop)

    ┌───1───┐
    │       │
    4       3
    │       │
    └───2───┘

• Use when: output feeds back into input (trading, real-time reactive systems)
• Architect position: center of ring
• Example: price data → strategy → trade → portfolio → risk limits → strategy
• Defensive circle — all-around coverage

Syntagma (Mesh / Dense Network)

  1 ←→ 2
  ↕  ╲╱ ↕
  4 ←→ 3

• Use when: every component genuinely depends on every other (use sparingly — O(n²) overhead)
• Dense grid — everyone connected to everyone

How to Apply This

As a Liaison (Legate):

1. Receive instructions from the Commander
2. Spin up a Tribune (Architect) and give it this framework
3. The Architect determines the product's data flow shape FIRST
4. Then designs the centurion network in that shape
5. Then spins up centurions and activates lateral links

As an Architect (Tribune):

1. Determine the product's data flow shape (Phalanx, Testudo, Wedge, Orbis, Syntagma)
2. Design centurion network in that shape — each centurion = one architectural module
3. Enforce the Decuria mandate — MUST have centurions, MUST delegate to them
4. Activate lateral links per phase — not all links are always on
5. Morph the topology when phases change
6. Never use a template. Every product gets its own shape.

Formation Announcement Protocol

Every time the Tribune selects a formation, they MUST post TWO things to the team's Slack channel:

1. The Formation Image — A screenshot of the HTML formation diagram showing:

• All centurions with their missions and status (COMPLETE/ADVANCING/BLOCKED/HOLDING)
• The Tribune hub at center/top
• Lateral links and connection lines between centurions
• NO command chain (Commander/Legate/Tribune row) in the image

2. Tactical Reasoning (Slack text) — Posted as initial_comment on the image upload:

• WHY this formation was chosen (what is the task's data flow shape?)
• The command chain: Commander → Legate → Tribune → Centurions
• How the formation maps to the task's architecture (Conway's Law)
• Which formations were REJECTED and why
• How centurions will communicate (lateral links, handoff protocol)

This protocol is MANDATORY. No formation activates without a public announcement and tactical reasoning. The Slack channel is the war room — and it's also content.

Visual Standard

• Image shows ONLY the formation (centurions + Tribune hub). No command chain in the image.
• Command chain, tactical reasoning, and rejected formations go in the Slack text message.
• Templates live in polymorphic-ai-teams/templates/ — one HTML per formation shape.

Available templates:

How to Generate and Post

1. Copy the appropriate template from polymorphic-ai-teams/templates/{formation}.html
2. Customize: update centurion names, missions, and statuses (classes: done, go, warn, wait)
3. Save to a temp file
4. Screenshot with Puppeteer + Chrome:

const puppeteer = require('puppeteer');
const browser = await puppeteer.launch({
    executablePath: '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
    headless: 'new', args: ['--no-sandbox']
});
const page = await browser.newPage();
await page.setViewport({ width: 500, height: 500, deviceScaleFactor: 2 });
await page.goto('file://' + tempFilePath);
await new Promise(r => setTimeout(r, 1500));
await page.screenshot({ path: outputPng, fullPage: true });
await browser.close();

5. Upload via mcp__slack__slack_upload_file with tactical reasoning in initial_comment

Design Tokens

• Background: #f9f6f1 (parchment)
• Font: Cinzel (Google Fonts)
• Borders: #c8b89a (warm), #8a7560 (strong)
• Complete: #6a9a5e border, #f6fbf5 bg (class: done)
• Advancing: #5a78aa border, #f5f7fc bg (class: go)
• Blocked: #c4945a border, #fcf8f2 bg (class: warn)
• Holding: #ddd8ce border, opacity 0.35 (class: wait)
• Canvas: 500px wide, deviceScaleFactor: 2

Example Formation Announcement

Image: screenshot of Phalanx template with customized centurion names/statuses.

Text (posted as initial_comment):

PHALANX FORMATION — [Mission Name]

Command chain: Abel (Commander) → Liaison (Legate) → Architect (Tribune) → C1-C4

Tactical reasoning:
The task is a layered build — each piece depends on the one before it.
Phalanx (linear advance) is correct because:
• Linear dependency chain — each rank advances behind the last
• No lateral communication needed between parallel workers
• Single convergence point at deployment

Formations rejected:
• Testudo — no central hub to protect
• Orbis — defensive, we're on offense
• Syntagma — too few centurions for dense grid

The 10 Principles

1. Conway's Law is not a suggestion — the org chart IS the architecture
2. Shape follows data flow — circular product = circular org
3. The centurion layer is mandatory — the invariant that enables polymorphism
4. Centurions talk laterally, decurios do not
5. Three things morph: centurion count, mission, lateral links
6. No templates — every product's org chart is derived from its unique data flow
7. Balance is dynamic — a gyroscope, not a table
8. Structure forces behavior — make bad management structurally impossible
9. The Architect is a gardener, not a chess master
10. Zero restructuring cost is the superpower — exploit it

Academic Status

As of March 2026, this concept is novel. No existing paper or framework proposes phase-dependent topology restructuring using HR org design theory for AI agent teams. Closest prior art: DyTopo (Feb 2026) for reasoning topology, DyLAN for dynamic agent selection. Full analysis in the repo.