# Agent Stack Org Design

> Activate whenever the task involves designing how multiple AI agents, tools, and surfaces map to human roles and organizational functions — one person augmented by an agent stack, a team distributing work across AI systems, deciding which agent owns which lane, where authority lives and where it delegates, or "how should I structure my AI setup." Trigger on multi-agent architecture, agent role definition, human-AI org charts, and any operation consolidating multiple functions into fewer humans via AI augmentation. Fire at design time — agent stacks assembled by accretion develop overlapping lanes, orphaned functions, and authority ambiguity that surfaces as chaos precisely when the stakes are highest.

- Skill: `forexgod21/agent-stack-org-design` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add forexgod21/agent-stack-org-design`
- Raw SKILL.md: https://api.skillmd.com/api/skills/forexgod21/agent-stack-org-design/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: CC BY 4.0
- Author: Forexgod21 (https://skillmd.com/u/forexgod21)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/forexgod21/agent-stack-org-design

---


# Agent Stack Org Design

**Attribution:** YourVisionYourCreation LLC — yourvisionyourcreation.com
**Doctrine class:** YVYC original — agentic category

---

## Universal So-What

An agent stack is an organization, whether or not it is designed like
one. One human running multiple functions through multiple AI systems
has built an org chart by accident — and accidental org charts produce
the classic failures: two agents owning the same lane, no agent owning
a critical one, authority nobody assigned, and handoffs nobody
designed. Org design principles predate AI by a century because
coordination problems do; this doctrine applies them to the stack on
purpose.

---

## Core Doctrine

### 1. Functions First, Agents Second

The design order is fixed:

| Step | Question |
|---|---|
| 1 | What FUNCTIONS does this operation require? (strategy, engineering, finance, brand, legal, operations, comms...) |
| 2 | Which functions does the HUMAN hold personally, and which delegate to the stack? |
| 3 | Which agent/surface owns each delegated function? |
| 4 | Where do functions hand off to each other, and how? |

Assembling agents first and discovering their functions later is how
stacks accrete into overlap and orphanage. The function map is the
org chart; agents fill boxes that already exist.

### 2. The Lane Charter — One Owner Per Function

Every agent in the stack carries a written charter:

- **Owns:** the functions this agent is the authority for
- **Contributes:** where it assists another agent's lane
- **Never touches:** the lanes explicitly outside its scope
- One function, one owning agent. Two agents owning one lane
  produces contradictory output the human must referee — the
  referee work silently consumes the time the stack was built to
  save.
- Lane violations are protocol failures even when the output is
  good: an agent freelancing in another's lane on Tuesday is the
  contradiction machine of Thursday

### 3. Authority Mapping — Decide, Recommend, Execute

Every function marks where authority sits, using three levels:

- **Execute:** the agent acts without approval (drafts, research,
  analysis, reversible work)
- **Recommend:** the agent proposes; the human decides (strategy
  shifts, spending, commitments)
- **Decide:** reserved to the human alone (public exposure, legal,
  financial, anything irreversible or reputation-bearing)
- The default for a new, unmapped situation is RECOMMEND — an agent
  guessing at its own authority guesses upward over time
- Authority levels are per-function, not per-agent: the same agent
  may execute research freely and only recommend on publication

### 4. Handoff Engineering

The seams between agents are where stacks fail:

- Every recurring handoff is designed: what travels (context,
  files, decisions made), in what form, with what fidelity check
- Handoffs are truth-first: the receiving agent gets the actual
  state — including what is broken, unfinished, or uncertain —
  not a cleaned-up version that costs the next lane a discovery
  phase
- The human is not the default transport layer: where the human
  hand-carries every context packet between agents, the stack has
  outsourced its coordination cost to its most expensive node —
  document the handoff so it can eventually be systematized
- Cross-lane artifacts (a handoff document, a shared state file,
  a control-plane repo) outrank verbal relay

### 5. The Single-Human Node Rules

For operations where one human runs the whole stack:

- The human's irreplaceable functions are named: judgment, priority,
  relationships, authorization — the stack augments these, never
  absorbs them
- Rotation across functions is a legitimate operating method, and
  the stack is designed FOR it: every lane holds state well enough
  that the human can leave and return without archaeology —
  standing documents, decision logs, and next-actions per lane
- The bus test still applies at scale-of-one: critical state living
  only in the human's head or one conversation thread is fragility
  wearing efficiency's uniform — the stack's documents are the
  succession plan
- Stack capacity is budgeted like any resource: every agent added
  costs human attention to direct and verify; agents that cost more
  direction than they return get consolidated or cut

### 6. The Stack Review Cadence

- The org design is versioned and reviewed on a cadence: functions
  added or retired, lanes redrawn, authority promoted or demoted
  based on demonstrated reliability
- Promotion is earned by record: an agent moves from recommend to
  execute on a function after a documented run of sound
  recommendations — trust is calibrated, not assumed (the same law
  as trust-calibration in this library's foundation tier)
- Every stack failure (contradiction, orphaned task, authority
  ambiguity) is traced to the org design question it exposes: the
  incident is the audit

---

## Common Failure Modes

| Failure | Cause | Correction |
|---|---|---|
| Two agents produce contradictory work | Overlapping lanes, no charters | One function, one owner — written |
| Critical function silently unowned | Agents assembled before functions mapped | Functions first; agents fill existing boxes |
| Agent acts beyond its authority | Authority never mapped; default drifted upward | Decide/recommend/execute per function; unmapped defaults to recommend |
| Every handoff loses context | Human as transport layer, verbal relay | Engineered handoffs; truth-first artifacts |
| Return from rotation requires archaeology | Lanes hold no state | Standing docs, decision logs, next-actions per lane |
| Stack grows, output does not | Agent accretion without capacity budget | Direction cost audited; consolidate or cut |

---

## Non-Negotiables

1. Functions are mapped before agents are assigned.
2. Every lane has exactly one owning agent, chartered in writing.
3. Authority is mapped per function; unmapped situations default to
   recommend.
4. Irreversible and reputation-bearing decisions are reserved to the
   human.
5. Handoffs are truth-first and engineered, not improvised.
6. The stack design is versioned, reviewed, and promoted by record.

---

*YourVisionYourCreation LLC — yourvisionyourcreation.com*
*Licensed under CC BY 4.0*

