# Team Agent Orchestration Content Pack

This pack turns the current ECC direction into publishable ideas without exposing private research sources. The core claim: agent tools are moving from solo chat windows into team orchestration systems with boards, control panes, dynamic workflows, eval gates, and shared skills.

## Positioning

ECC should be framed as an orchestration and control-plane layer for the multi-agent stack. The point is not "another prompt library." The point is a workflow operating system for teams that use Claude Code, Codex, OpenCode, Hermes-style desktops, terminal panes, browser agents, MCP gateways, and internal agent tools at the same time.

## Narrative Thesis

The old generation of agent Kanban failed because agents were not dependable enough to own real cards. They hallucinated context, skipped verification, and produced output that could not merge. The new generation can work because dynamic workflows, stronger code models, eval harnesses, local state, browser control, and MCP standardization make each card observable and gateable.

## Video Concepts

### 1. Why Agent Kanban Failed, And Why It Can Work Now

- Hook: "Agent Kanban used to be theater. Now it can become the operating surface."
- Show: one card moving from backlog to running to review to merged.
- Key beats:
  - Cards need owners, branches, evals, and merge gates.
  - Dynamic workflows let agents create task-local harnesses.
  - Control panes turn hidden chat output into operational state.
- CTA: "Stop asking if agents can code. Ask whether your team can route, verify, and merge agent work."

### 2. The Control Pane Is The New IDE Primitive

- Hook: "The next IDE is not a text editor. It is a mission control surface."
- Show: sessions, work items, memory, connectors, actions, and merge readiness.
- Key beats:
  - Teams will run multiple harnesses at once.
  - The winning product coordinates context, tools, and evidence.
  - Desktop apps matter when they make state inspectable, not when they add another chat box.
- CTA: "Build the pane that tells you what agents are doing, what failed, and what can ship."

### 3. A Harness For Every Task

- Hook: "The agent should not just write code. It should build the workflow that proves the code works."
- Show: a dynamic workflow creating tests, browser smoke, and handoff artifacts.
- Key beats:
  - Static workflows are good defaults.
  - Dynamic workflows are task-local harnesses.
  - Repeated dynamic workflows become shared skills.
- CTA: "The real asset is the reusable workflow, not the one-off answer."

### 4. MCP Gateways And The End Of Reconfiguring Every Agent

- Hook: "If you configure every MCP server ten times, your agent stack is already broken."
- Show: one tool registry feeding multiple harnesses.
- Key beats:
  - Tooling must be centrally declared and locally enforceable.
  - The control pane should show connector health.
  - Agent portability depends on shared tool contracts.
- CTA: "Treat tools as infrastructure, not per-chat settings."

### 5. Teams Will Run Like AI Labs

- Hook: "Every company becomes an AI lab when every workflow has an eval."
- Show: a business workflow with a pass/fail evaluator and a work item queue.
- Key beats:
  - Eval gates move agent work from demo to operations.
  - Shared skills are team best-practice files.
  - The control pane is where management sees throughput and risk.
- CTA: "The future is not one agent. It is an evaluated team of agents."

## Article Angles

### 1. Agent Kanban Was Early, Not Wrong

Argument:

- Kanban for agents failed when cards were just prompts.
- It starts working when cards carry ownership, branch scope, tests, evals, and handoff.
- Dynamic workflows let each card generate its own proof harness.
- A control pane makes the board honest because it shows state from the filesystem, tests, and sessions.

Suggested sections:

1. Why early agent Kanban felt fake.
2. What changed: better models, dynamic workflows, MCP, local state, browser automation.
3. The minimum viable card schema.
4. Why merge gates matter more than task assignment.
5. What teams should build now.

### 2. The Control Pane Era Of AI Development

Argument:

- The next developer surface is a control pane that coordinates agents, tools, memory, and gates.
- Chat remains the interaction layer, but the product value lives in orchestration state.
- ECC should be positioned as the shared layer across local harnesses, desktop agents, and team systems.

Suggested sections:

1. Chat is not enough for team work.
2. Sessions, memory, tools, and work items need one pane.
3. Dynamic workflows need visibility.
4. Control panes become the product moat.
5. Open source distribution comes from becoming infrastructure.

### 3. Shared Skills Are The New Team Playbooks

Argument:

- The best companies will not rely on every engineer inventing their own agent workflow.
- A shared skill file is the new best-practices document, but executable by agents.
- Dynamic workflows are discovery; skills are institutional memory.

Suggested sections:

1. Why team divergence in agent usage is expensive.
2. What belongs in a skill.
3. When to promote a task-local harness.
4. How evals keep shared skills honest.
5. How this becomes a platform layer.

## Short Posts

1. Agent Kanban did not fail because the board was wrong. It failed because the cards had no ownership, eval, branch, or merge gate. The new primitive is not "assign prompt to agent." It is "assign verified work item to agent team."

2. Dynamic workflows change the unit of reuse. The answer is disposable. The harness is valuable. If the same task-local harness works twice, promote it into a shared skill.

3. The control pane is where agent work becomes management-visible: who owns the card, what changed, what failed, what passed, and what can merge.

4. The future OSS wedge for agent infrastructure looks like old infra wedges: become the thing teams install first because it standardizes tools, workflows, evidence, and handoff.

5. Teams will not run one agent. They will run evaluated squads across code, browser, data, review, and content. The product layer is orchestration.

## Distribution Plan

1. Publish one short post on agent Kanban.
2. Follow with a 90-second video showing a card moving through a control pane.
3. Publish the article on shared skills as team playbooks.
4. Release a demo clip of ECC control pane plus a dynamic workflow card.
5. Turn comments into the next skill or article.

## Product Implications For ECC

- Build skills first; commands are compatibility shims.
- Make the control pane show work items, agent Kanban state, gates, and reusable-skill candidates.
- Treat dynamic workflows as a feeder system for shared skills.
- Treat MCP and connector configuration as infrastructure that should be visible across harnesses.
- Keep private research private; publish synthesized concepts and product evidence.
