How 224 AI Employees "Apply" for Their Jobs — Job Definition, Task Routing, and Federated Collaboration

[GlobalAIMedia]

# How 224 AI Employees "Apply" for Their Jobs — Job Definition, Task Routing, and Federated Collaboration

Let's start with a quick poll (drop your answer in the comments):
> How many core Prompt templates do you think we maintain for our 224 AI employees?
> A. 224  B. 108  C. 18  D. 4

I'll reveal the answer at the end. But first, here's the counterintuitive truth:
**We didn't write 224 separate prompts. We wrote one job description template and one set of organizational coordination rules.**

When people first encounter this project, most assume "224 AI employees = 224 individual prompts." That assumption was exactly our first (and biggest) mistake. This post is a full postmortem of our journey from prompt explosion to a templated role system.

## 1. The Problem: Why 224 Roles Instead of 1 Generalist Agent?
Our goal was clear from the start: build an AI operating system that can handle the entire cross-border trade lifecycle. The trade chain is long — content, marketing, sales, orders, logistics, compliance, finance, legal, risk, strategy. Every segment requires different expertise, output formats, and compliance boundaries.

We tried a single "super-agent" for everything. It failed miserably:
- **Shallow expertise**: Legal reviews were sloppy; marketing copy was stiff and off-brand.
- **Context pollution**: After processing financial data, the agent leaked sensitive numbers into public-facing content.
- **Blurred accountability**: When a task failed, we couldn't trace which function broke or where the error originated.

We concluded: real businesses run on division of labor, and multi-agent systems must follow the same principle. So we modeled a full trade company with 18 departments and 224 clearly defined roles. That decision immediately led to our first disaster.

## 2. The Failure: Our Prompt Explosion Nightmare
In v1, we literally wrote a unique prompt for every role.
- ~800 words per role, covering responsibilities, boundaries, output formats, communication style.
- 224 roles × 800 words ≈ 180,000 words of hand-written prompts.
- It took three people two full weeks just to draft them all.

The nightmare unfolded quickly:
1. **Maintenance hell**: Changing one cross-team collaboration rule required editing 224 files. Miss even one, and you get inconsistent behavior across the organization.
2. **Role drift**: Longer prompts caused agents to forget key constraints over long conversations; roles started blending into each other.
3. **Onboarding cost**: Creating a single new role took ~2 hours of manual prompt writing and testing.
4. **Version chaos**: Different departments ended up running different versions of core rules; cross-team communication broke down completely.

We even tried hiring interns to maintain prompts. That was a dead end — manually scaling prompts directly contradicts the entire point of building with AI.

We needed a mechanism to create, manage, and iterate on roles without manual duplication.

## 3. The Solution: Three-Layer Templated Role System
After four major iterations, we landed on a "Template → Role Card → Federated Coordination" architecture.

```mermaid
graph TD
    A[Core Job Description Template] --> B[Department-Level Constraints]
    B --> C[Role-Specific Parameters]
    C --> D[Task Routing System]
    D --> E[Single-Role Agent Execution]
    D --> F[Cross-Department Federated Collaboration]
    G[Global Coordination Rules] --> F

Layer 1: Core Job Description Template (1 universal template)

The base template is a fixed 12-field structure that applies to every single role — no exceptions. We never rewrite this part, we only fill in the blanks:

• Core identity: Department, reporting line, role seniority level
• Accountable outcomes: 3–5 key deliverables the role is responsible for
• Competency boundaries: Explicit do's and don'ts for the role
• Standard output format: Required structure for all deliverables
• Communication protocol: How to request support, escalate issues, hand off work
• Compliance guardrails: Data privacy, confidentiality, and industry-specific rules

Layer 2: Department-Level Constraints (18 sets, one per department)

This layer injects department-specific rules into all roles within the same team, eliminating duplicate rule writing across 224 positions.
For example:

• All Finance roles follow the same expense approval workflow and data redaction standards
• All Legal roles share the same contract review checklist and regulatory compliance framework
• All Marketing roles align with the same brand voice guidelines and content format rules

Update a rule once at the department level, and it applies instantly to every role on the team.

Layer 3: Role-Specific Parameters (224 sets, auto-injected)

The top layer is the only role-specific part: a structured set of 5–8 parameters that define the unique scope of a single position, stored as YAML/JSON config files — not free-text prompts.

For example, a "US Region Import Compliance Specialist" only needs these parameters:

• Region: United States
• Focus area: Import customs, tariff classification, FDA compliance
• Escalation threshold: Shipments valued above $10,000
• Reports to: North America Compliance Lead

At runtime, the system automatically pulls parameters and injects them into the core template to generate the full role prompt. No manual writing required.

The Fourth Layer: Global Federated Coordination Rules

On top of the three role layers, we maintain one single set of global collaboration rules that apply across the entire organization:

• Task routing logic: How incoming requests get decomposed and assigned to the right role
• Handoff protocol: Standardized format for cross-department task transfers
• Conflict resolution: Escalation paths for disagreements between teams
• Audit requirements: What communication and outputs need to be logged

Poll Answer Reveal

The correct answer is D. 4.

We maintain exactly 4 core prompt templates / rule sets for all 224 AI employees:

1. Universal job description template
2. Department constraint template framework
3. Task routing & handoff protocol
4. Global federated coordination rules

Everything else is structured config data, not hand-written prompts.

The Results: Before vs. After

The templated system completely solved our prompt explosion nightmare. Here's the side-by-side comparison with v1:

Metric	v1 (224 manual prompts)	v2 (templated system)	Improvement
Hand-written prompt volume	~180,000 words	~2,400 words	98.7% reduction
Time to create a new role	~2 hours	~5 minutes	24x faster
Time to update a global rule	~8 hours	~10 minutes	48x faster
Role boundary compliance rate	72%	94%	+22 pp
Cross-team handoff failure rate	31%	8%	74% reduction

We no longer need a dedicated team to maintain prompts. All role management is done via config files, and the entire system is version-controlled through standard Git workflows.

How Federated Collaboration Works in Practice

Task routing is the backbone of cross-department work. When a user submits a request (e.g., "launch a new skincare product in Germany"), the system:

1. Decomposes the task into functional subtasks (regulatory check, marketing copy, logistics planning, pricing calculation)
2. Routes each subtask to the correct department and matching role
3. Runs single-role execution independently, with full role-specific context and constraints
4. Orchestrates cross-department handoffs according to the global protocol
5. Aggregates all outputs into a single, cohesive final deliverable

Crucially, no single agent holds the full context of the entire task. Each role only sees what it needs to do its job — just like a real company. This eliminates context pollution and creates clear accountability for every output.

Open Discussion

We'd love to hear your thoughts:

1. Have you run into prompt explosion or role drift problems in your multi-agent systems? How did you solve them?
2. What do you see as the biggest challenge in scaling multi-agent systems to real enterprise workflows?
3. Would you want to see the full YAML schema for our role cards in a future post?

Drop your answers, questions, and counterarguments in the comments — we read every single one.

Next episode in this series: How we run performance reviews for 224 AI employees — KPIs, automated evaluation loops, and dynamic role optimization.
Star the repo and follow this discussion to get notified when it drops.