25 AI Agents: Excalidraw to Linear

Build a 25-agent pipeline that ships Excalidraw canvases to Linear tickets.

Introduction

30 Second Summary

Everyone brainstorms. You sketch ideas on whiteboards, sticky notes, or digital canvases. The hard part is turning those scattered visual thoughts into organized work that actually ships.

In this project, you will build a local Excalidraw brainstorming tool inside Obsidian where 25 AI agents process your visual thinking through strategy, synthesis, and delivery pipelines. The output lands as tracked tickets in Linear with Initiative goal attachment.

What You'll Build

A client-agnostic 25-agent pipeline living in an Obsidian vault that turns Excalidraw canvas sketches into stakeholder-ready deliverables and Linear tickets, driven by any AI client you choose on any given day.

By the end of this project, you'll have:

  • A fully designed system with Architecture Decision Records and Mermaid diagrams documenting every design choice before writing a single config file.
  • A client-agnostic 25-agent pipeline that any AI client (Claude Desktop, Cursor, Gemini, or Codex) can pick up and run without reconfiguration.
  • 3 completed real-world cycles producing stakeholder-ready deliverables (executive migration roadmap, content strategy brief, AI transformation proposal) tracked in Linear with goal attachment.
  • Secret Mission: Wire a practice-compounding loop with 3-model triangulation and produce a system evaluation scorecard targeting >= 98/100 against all original requirements.

Are there any prerequisites?

You should be comfortable with AI prompting and have a basic understanding of project management concepts like stories, sprints, and backlogs. You also need Node.js installed and Obsidian set up with the Excalidraw plugin enabled.

Verify Tools and Configure Workspace

Before designing architecture or writing configurations, you need a verified foundation. This project depends on Node.js for running MCP servers, Claude Desktop for AI orchestration, and an Obsidian vault with specific plugins for knowledge management.

In this step, you will confirm each tool is accessible, install the Obsidian plugins your pipeline needs, and create the vault that becomes your entire system.

In this step, get ready to:
  • Verify Node.js, Claude Desktop, and Obsidian with Excalidraw.
  • Install Dataview, Templater, and Git plugins in Obsidian.
  • Create the IdeationCouncil vault and confirm portability with at least 2 AI clients.
Verify your core toolchain

Node.js powers the MCP servers that connect your AI clients to the vault and to Linear. You need to confirm it is accessible from your terminal before wiring anything.

  • Press the Windows key to open your search bar.
  • Type PowerShell and press Enter to open it.
  • Verify Node.js is accessible by running this command:
node --version
  • You should see a version number printed (e.g. v20.x.x or higher).
  • Verify npm is also accessible by running:
npm --version
  • You should see an npm version number (e.g. 10.x.x).

Command not found?

If PowerShell does not recognize node or npm, Node.js may not be on your system PATH. Close and reopen PowerShell after installing Node.js. If you installed it recently, a restart may be required for PATH changes to take effect.

Help me fix Node.js not being found in PowerShell on Windows.

Next, confirm Claude Desktop is ready. This is the AI client you will use for most of this project's orchestration.

  • Press the Windows key to open your search bar.
  • Type Claude and press Enter to open Claude Desktop.

✔️ Claude Desktop opens and I'm logged in

You are ready to go. Claude Desktop will be your primary AI client for MCP server connections in later steps.

ⓧ I don't have Claude Desktop installed

  • Visit claude.ai/download in your browser.
  • Click Download for Windows.
  • Open the downloaded installer and follow the prompts.
  • Launch Claude from the Start Menu and sign in with your Claude account (Free or Pro both work).

System requirements

Claude Desktop requires Windows 10 or later.

Finally, confirm Obsidian with Excalidraw is ready. Then install the three additional community plugins your pipeline needs.

  • Press the Windows key to open your search bar.
  • Type Obsidian and press Enter to open it.
  • Open Settings (gear icon in the bottom-left corner).
  • Select Community plugins in the left sidebar.
  • Confirm that Excalidraw appears under Installed plugins and its toggle is enabled.

Now install the three additional plugins: Dataview (for querying vault files), Templater (for template automation), and Git (for version control).

  • In the Community plugins settings pane, click Browse.
  • Type Dataview in the search box.
  • Select the Dataview plugin by Michael Brenan, then click Install.
  • Click Enable to activate Dataview.
  • Repeat the same process for Templater (by SilentVoid) and Git (by Vinzent): search, install, and enable each one.
  • Close the Browse panel and return to Community plugins settings.
  • Confirm that Excalidraw, Dataview, Templater, and Git all appear under Installed plugins with their toggles enabled.

What do these plugins do?

Dataview lets you query your vault like a database. You will use it to verify agent counts and check file completeness across folders.

Templater provides programmable templates with variables and logic. Your agent files use Templater syntax for reusable prompts. Git tracks vault changes and enables version-controlled collaboration.

Can't find Community plugins?

If you see a message about Restricted Mode, click Turn on community plugins first. This disables Restricted Mode and allows you to browse and install third-party plugins.

Help me enable community plugins in Obsidian.

Verify AI clients for portability

The system you are building is client-agnostic. The vault is the constant. The AI client is interchangeable. To prove portability, you need at least 2 working AI clients.

  • Confirm you have access to at least 2 of the following AI clients:
  • Open your second AI client and confirm you can start a conversation or access files.

Why do I need 2 AI clients?

You only need one client to build. Having 2+ proves the portability principle. If Claude Desktop hits free-tier rate limits during a Council run, you can seamlessly continue in Gemini or Cursor without reconfiguring anything.

Each client accesses the same vault through its own interface. Claude Desktop reads it via filesystem MCP. Cursor reads it as a workspace. Gemini reads it via copy-paste or CLI.

Create the vault and initialize your project root

Everything in this project lives in a single Obsidian vault. Configurations, agents, canvases, ADRs, and outputs all go here. This folder IS the system.

  • In Obsidian, click the vault switcher icon (vault icon in the bottom-left corner, below Settings).
  • Click Create new vault.
  • Enter IdeationCouncil as the vault name.
  • Set the location to C:\Users\your Windows username\Documents.
  • Click Create.

Obsidian opens the new vault. You should see an empty file list in the left sidebar. The vault lives at C:\Users\<username>\Documents\IdeationCouncil.

  • Re-enable your community plugins in this new vault by opening Settings > Community plugins > Turn on community plugins.
  • Install and enable Excalidraw, Dataview, Templater, and Git in this new vault using the same process as before (Browse, search, Install, Enable for each).
  • Confirm all 4 plugins show as enabled under Installed plugins.

Why a new vault instead of using an existing one?

A dedicated vault keeps your agent pipeline, canvases, and governance config isolated from personal notes. When you point MCP servers at this vault in the next step, they only access project files.

  • Verify the vault folder exists by switching to your PowerShell window and running:
ls ~\Documents\IdeationCouncil
  • You should see a .obsidian folder listed. This confirms Obsidian created the vault structure at the correct location.

Don't see the .obsidian folder?

Hidden folders may not display by default. Run ls -Force ~\Documents\IdeationCouncil to show hidden items. If the folder does not exist at all, double-check the location you chose when creating the vault in Obsidian.

Help me find my Obsidian vault folder on Windows.

Your toolchain is verified and your vault is live. Next up, you will design the system architecture with ADRs, Mermaid diagrams, and an implementation plan before writing a single config file.

Design Phase — ADRs, Architecture Diagrams, and Implementation Plan

Your vault is open and your tools are ready. Before building a single configuration file, you need to design the system with proper engineering discipline.

In this step, you will document every major architectural decision, visualize how the subsystems connect, and write the implementation plan that guides the rest of the build. This design-first approach means you will never be guessing why something was built a certain way.

In this step, get ready to:
  • Write 5 Architecture Decision Records documenting your system's key choices.
  • Generate 4 Mermaid architecture diagrams that visualize the system.
  • Write an implementation plan with build phases, dependencies, and portability criteria.
Write 5 Architecture Decision Records

An Architecture Decision Record (ADR) is a short document that captures one architectural choice, its context, and its consequences. You will write 5 ADRs covering the core design decisions for your system.

  • Open PowerShell (press the Windows key, type PowerShell, and press Enter).
  • Navigate to your vault and create the ADRs folder by running these commands:
cd [[VAULT_PATH="C:\Users\YourUsername\Documents\IdeationCouncil"]]
mkdir Specs\ADRs

What does this do?

This creates a Specs\ADRs folder inside your vault. All 5 ADRs will live here as Markdown files that Obsidian treats as first-class notes.

Each ADR follows the Nygard format: Title, Status, Context, Decision, Consequences. Here is the structure your ADRs should follow:

# ADR-001: Obsidian as Vault Backbone

## Status

Accepted

## Context

<!-- Describe the forces that led to this decision -->
<!-- Why do we need a vault backbone at all? -->
<!-- What alternatives exist (Notion, Google Docs, plain filesystem)? -->

## Decision

<!-- State the choice in active voice -->
<!-- e.g. "We will use Obsidian as the single source of truth for all system files." -->

## Consequences

<!-- List positive, negative, and neutral outcomes -->
<!-- e.g. Positive: local-first, no vendor lock-in -->
<!-- e.g. Negative: requires desktop app, no native mobile editing -->

What is the Nygard format?

Michael Nygard's ADR format uses short noun-phrase titles, a Status field (proposed, accepted, deprecated, or superseded), value-neutral Context describing the forces at play, the Decision in active voice, and Consequences listing all outcomes.

The point is not to justify a decision after the fact. It is to capture the reasoning at the moment of choosing so future-you (or your team) never has to guess.

  • Open your preferred AI client (Claude Desktop, Cursor, Gemini, or any client you verified in Step 1).
  • Give it the following prompt to generate all 5 ADRs:
Generate 5 Architecture Decision Records in Nygard format (Title, Status, Context, Decision, Consequences) as separate Markdown files.

Save them to Specs/ADRs/ in my vault at [[VAULT_PATH="C:\Users\YourUsername\Documents\IdeationCouncil"]].

The 5 ADRs:
- ADR-001: Obsidian as Vault Backbone (why Obsidian over Notion, Google Docs, or plain filesystem)
- ADR-002: Linear as Delivery Target (why Linear over Jira, GitHub Issues, or Trello)
- ADR-003: Client-Agnostic Agent Design (why agents are Markdown templates any AI can read, not locked to one client)
- ADR-004: Canvas-First Ideation with Excalidraw (why visual brainstorming on a canvas before text-based specs)
- ADR-005: MCP as the Integration Layer (why MCP over direct API calls or custom scripts)

Each ADR should have:
- Status: Accepted
- Context: 2-3 sentences describing the forces and alternatives considered
- Decision: 1-2 sentences in active voice stating the choice
- Consequences: 3-5 bullet points covering positive, negative, and neutral outcomes

If your AI client cannot write files directly

Some clients (like Gemini web or Claude Desktop without MCP configured yet) cannot write directly to your filesystem. In that case, copy the generated content and create each file manually in Obsidian.

In Obsidian, press Ctrl+N to create a new note, then rename it to the full path like Specs/ADRs/ADR-001. Obsidian creates the folder structure automatically.

  • Verify all 5 ADR files exist in your vault. In Obsidian's Explorer sidebar (left panel), expand Specs > ADRs.
  • You should see 5 files: ADR-001.md through ADR-005.md.
  • Click into ADR-001.md and confirm it has all 5 Nygard sections: Title, Status (Accepted), Context, Decision, Consequences.

Don't see the files in Obsidian?

If files were created via the terminal or an AI client but do not appear in Obsidian, click anywhere in the vault sidebar and press Ctrl+R to reload. Obsidian sometimes needs a refresh to detect new files.

If the folder path is wrong, check that the files are inside Specs\ADRs\ relative to your vault root, not nested under another folder.

Help me troubleshoot missing ADR files in my Obsidian vault

Generate Mermaid architecture diagrams

With your decisions documented, you need to visualize the system. Mermaid diagrams render directly inside Obsidian Markdown files as fenced code blocks, giving you live architecture views without leaving the vault.

  • Create the architecture folder by running this command in PowerShell:
mkdir Specs\architecture

You need 4 diagrams that show the system from different perspectives. Here is an example of the System Context diagram so you know what the output should look like:

# System Context Diagram

Shows the operator, AI clients, vault, and external systems at the highest level.

```mermaid
graph TD
    Operator[Human Operator] --> AIClients[AI Clients]
    AIClients --> Vault[Obsidian Vault]
    Vault --> Linear[Linear]
    Vault --> Excalidraw[Excalidraw Canvas]

    AIClients --> |Claude Desktop| Vault
    AIClients --> |Cursor| Vault
    AIClients --> |Gemini| Vault
    AIClients --> |Codex| Vault

    subgraph External Systems
        Linear
        Excalidraw
    end
```

What does this diagram show?

The System Context diagram is the highest-level view. It shows the human operator, the interchangeable AI clients, the vault as the central hub, and the external systems (Linear and Excalidraw) the pipeline delivers to.

The key insight: AI clients are interchangeable. The vault is the constant.

  • Use your AI client to generate all 4 diagram files with this prompt:
Generate 4 Mermaid architecture diagrams as Markdown files in Specs/architecture/ in my vault.

Each file should have a title, a brief description, and a fenced Mermaid code block.

The 4 diagrams:
1. system-context.md - System Context: operator, AI clients (Claude Desktop, Cursor, Gemini, Codex), vault, Linear, Excalidraw. Show that AI clients are interchangeable and the vault is the hub.

2. subsystem-decomposition.md - Subsystem Decomposition: Show 4 subsystems and their interfaces:
   - Visual Ideation Engine (Excalidraw + Team C): thoughts become canvases
   - Intelligence Layer (Teams A + B): strategy, expertise, red-teaming
   - Synthesis Pipeline (Team D): canvases become specs, ADRs, INVEST stories
   - Delivery Bridge (Team E + Linear MCP): stories become tracked tickets

3. agent-orchestration-flow.md - Agent Orchestration Flow: Show the Council Lead routing work through Teams A, B, C, D, and E in sequence with decision points.

4. cycle-lifecycle.md - Cycle Lifecycle: Show the full cycle from intake (operator picks scenario) through ideation, intelligence, synthesis, standards gate, to Linear delivery.

Use graph TD or sequenceDiagram syntax as appropriate for each.
  • Verify the diagrams render in Obsidian. Open system-context.md in Obsidian and switch to Reading View (click the book icon in the top-right, or press Ctrl+E).
  • You should see a rendered flowchart with boxes and arrows instead of raw text.
  • Check that all 4 files exist in the Explorer sidebar under Specs > architecture: system-context.md, subsystem-decomposition.md, agent-orchestration-flow.md, and cycle-lifecycle.md.

Mermaid diagram not rendering?

Make sure you are in Reading View (not Editing View). Mermaid renders only in reading mode in Obsidian by default.

Check that the code fence uses exactly ```mermaid (lowercase, no space). A typo like ```Mermaid or ``` mermaid will not trigger rendering.

Help me fix a Mermaid diagram that is not rendering in Obsidian

Write the implementation plan

The implementation plan is your project manager's view of the build. It breaks the remaining work into phases with clear dependencies and a definition of done for each.

  • Use your AI client to generate the implementation plan with this prompt:
Generate Specs/implementation-plan.md in my vault with the following structure:

# Implementation Plan

## Build Phases

6 phases in order:
1. Phase 1: Infrastructure - Vault structure, MCP configs, Linear workspace setup
2. Phase 2: Design - ADRs, architecture diagrams, this implementation plan (DONE)
3. Phase 3: Agents - 25 agent templates + Council Lead deployed to vault
4. Phase 4: Canvas Templates - 7 Excalidraw templates + governance configs
5. Phase 5: Integration Test - Run 3 real-world scenarios end-to-end
6. Phase 6: Validation - Standards gate, Linear delivery, system evaluation scorecard

## Dependency Graph

Show which phases depend on which (as a Mermaid diagram):
- Phase 2 depends on Phase 1
- Phase 3 depends on Phase 2
- Phase 4 depends on Phase 2
- Phase 5 depends on Phases 3 AND 4
- Phase 6 depends on Phase 5

## Definition of Done (per phase)

For each phase, list 3-4 concrete criteria that prove the phase is complete.

## Client-Agnostic Portability Test Criteria

List the tests that prove the system works with any AI client:
- Test 1: A different client than the build client can read and summarize the Council Lead
- Test 2: Agent templates contain no client-specific syntax or references
- Test 3: All file paths are relative to vault root (no absolute paths)
- Test 4: Governance configs reference roles, not specific AI products

Why portability test criteria?

The portability criteria ensure your system is never locked to a single AI client. If Claude Desktop goes down, you open Cursor. If Cursor is unavailable, you copy-paste into Gemini. The vault is the constant. The AI client is interchangeable.

  • Save the generated file as Specs/implementation-plan.md in your vault (if your AI client did not save it directly).
  • Open implementation-plan.md in Obsidian and confirm it contains all 4 sections: Build Phases (6 phases), Dependency Graph (with Mermaid), Definition of Done, and Portability Test Criteria.
  • Switch to Reading View (Ctrl+E) to confirm the dependency graph renders as a Mermaid diagram.

Implementation plan missing sections?

If your AI client produced a partial plan, re-prompt with the specific missing section. AI clients sometimes truncate long outputs. Ask for one section at a time if needed.

Help me complete my implementation plan file

Verify the full Specs folder structure by running this command:

Get-ChildItem -Recurse Specs

You should see 10 files total: 5 ADRs in Specs\ADRs\, 4 diagrams in Specs\architecture\, and Specs\implementation-plan.md at the top level.

Your system is now fully designed before a single configuration file has been written. You have 5 ADRs that explain every major choice, 4 diagrams that show how everything connects, and a phased plan with clear dependencies. Next up, you will wire the MCP servers that let your AI clients read and write to this vault and to Linear.

Wire MCP Servers and Set Up Linear

Your design phase is complete. You have 5 ADRs, 4 Mermaid architecture diagrams, and a full implementation plan documenting exactly what you are building and why.

Now you need to connect the system to the outside world. MCP (Model Context Protocol) servers are how AI clients read your vault and push tickets to Linear. In this step, you will wire project-level configs so that any AI client loading this workspace gets instant MCP access, configure Claude Desktop's one-time system config, and stand up your Linear workspace with teams and Initiatives.

In this step, get ready to:
  • Create project-level MCP configs for Cursor and VS Code.
  • Configure Claude Desktop's system-level MCP config.
  • Set up a Linear workspace with teams, Initiatives, and a Personal API key.
Create project-level MCP configs

Project-level configs live inside your vault. Any AI client that opens the vault as a workspace picks them up automatically. This is what makes the system portable. Move to a new machine, clone the vault, MCP works.

Cursor and VS Code use slightly different config schemas, so you need one file for each.

  • In your IdeationCouncil vault folder, create a .cursor folder and a file called mcp.json inside it.
  • Paste the following into .cursor/mcp.json:
{
  "mcpServers": {
    "filesystem": {
      "command": "cmd",
      "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-filesystem", "C:\\Users\\[[USERNAME=\"your Windows username\"]]\\Documents\\IdeationCouncil"]
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
    }
  }
}

What does this config do?

The filesystem server gives Cursor read/write access to your vault directory using the @modelcontextprotocol/server-filesystem package. The cmd /c npx pattern is required on Windows because npx does not run directly as a spawned command in the MCP server launcher.

The linear server connects to Linear's remote MCP endpoint at https://mcp.linear.app/mcp using Streamable HTTP with OAuth 2.1. The first time you connect, it will trigger a browser-based OAuth flow to authorize access.

  • Now create a .vscode folder in the vault root and a file called mcp.json inside it.
  • Paste the following into .vscode/mcp.json:
{
  "servers": {
    "filesystem": {
      "type": "stdio",
      "command": "cmd",
      "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-filesystem", "C:\\Users\\[[USERNAME=\"your Windows username\"]]\\Documents\\IdeationCouncil"]
    },
    "linear": {
      "type": "http",
      "url": "https://mcp.linear.app/mcp"
    }
  }
}

Why is the VS Code config different?

VS Code uses "servers" as the top-level key (not "mcpServers"). Each server also requires a "type" field. The filesystem server uses "stdio" (local command), and the Linear server uses "http" (remote endpoint). Same servers, different schema.

  • Confirm both files exist by running this in PowerShell from your vault root:
ls .cursor/mcp.json, .vscode/mcp.json

You should see both files listed in the output.

Files not showing up?

Make sure you created the folders .cursor and .vscode at the vault root (C:\Users\<username>\Documents\IdeationCouncil), not inside a subfolder. The dot-prefix makes them hidden on some systems. Use ls -Force in PowerShell to see hidden folders.

help me troubleshoot my MCP config files not appearing in my vault root

Configure Claude Desktop system config

Claude Desktop is the one AI client that requires a system-level config file. Every other client reads project-level configs from the workspace. This is a one-time setup.

  • Open File Explorer and navigate to %APPDATA%\Claude. You can paste this path directly into the address bar.
  • Open or create claude_desktop_config.json in a text editor.
  • Add the following MCP server entries (if the file already has content, merge the mcpServers entries into the existing object):
{
  "mcpServers": {
    "filesystem": {
      "command": "cmd",
      "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-filesystem", "C:\\Users\\[[USERNAME=\"your Windows username\"]]\\Documents\\IdeationCouncil"]
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
    }
  }
}

What is this file?

This is Claude Desktop's system-level config located at %APPDATA%\Claude\claude_desktop_config.json. It uses the same mcpServers key structure as Cursor. The filesystem server points to your vault so Claude can read and write files. The Linear server uses mcp-remote to proxy the remote endpoint.

  • Save the file.
  • Fully quit Claude Desktop (right-click the system tray icon and choose Quit).
  • Relaunch Claude Desktop.
  • In the Claude Desktop chat, ask Claude to list the files in your vault. Type something like: "List the folders in my IdeationCouncil vault."

Claude should respond with the folder structure including Specs/ and its subfolders. This confirms the filesystem MCP is connected.

Claude can't see your vault files?

Check the MCP logs at %APPDATA%\Claude\logs. Look for mcp.log or mcp-server-filesystem.log for error details.

If you see an ENOENT error referencing ${APPDATA}, add an env key to the filesystem server entry: "env": { "APPDATA": "C:\\Users\\<username>\\AppData\\Roaming\\" }.

help me debug why Claude Desktop cannot connect to my filesystem MCP server on Windows

Set up Linear workspace

Linear is where your agent pipeline delivers tracked tickets. The free tier gives you everything you need: Issues, Projects, Cycles, Initiatives, MCP access, and unlimited members.

  • Open your browser and go to linear.app.
  • Click Sign Up and create a new workspace on the free plan ($0, 250 issues, 2 teams).
  • When prompted for a workspace name, enter something meaningful like IdeationCouncil or your preferred name.
  • Create your first team: click Settings (gear icon in the sidebar), then Teams.
  • Click New Team and name it Strategy.
  • Create a second team named Delivery.

Why two teams?

The Strategy team handles high-level planning work (ADRs, specs, architecture decisions). The Delivery team handles implementation tickets (INVEST stories, engineering tasks). This mirrors how the 5 agent teams split their responsibilities across the pipeline.

  • Now create a parent Initiative. In the sidebar, click Initiatives (or find it under Projects depending on your Linear layout).
  • Create an Initiative called Q3 2026 Delivery Pipeline.
  • Inside this parent Initiative, create 3 sub-Initiatives:

Each sub-Initiative corresponds to one of the 3 real-world Council sessions you will run in Step 6.

  • Finally, generate a Personal API key as backup authentication. Go to Settings, then Security and Access, then Personal API Keys.
  • Click Create Key, give it a label like IdeationCouncil, and copy the key somewhere safe (a password manager or local notes file).

Why a Personal API key?

The primary connection to Linear uses OAuth via MCP (the browser flow that triggers on first connection). The Personal API key is backup auth for environments where the browser OAuth flow is not available, such as headless terminals or CI pipelines.

You should now see your Linear workspace with 2 teams and 3 sub-Initiatives under the parent Q3 2026 Delivery Pipeline Initiative.

Linear MCP connection triggering OAuth?

The first time an AI client tries to use the Linear MCP, your browser will open asking you to authorize access. This is expected. Click Allow and the token persists for future sessions.

help me authorize the Linear MCP OAuth flow in Claude Desktop

Your infrastructure is wired. MCP connects your vault to any AI client, and Linear is ready to receive tickets. Next up, you will deploy the 25 agent templates that drive the entire pipeline.

Deploy 25 Agent Templates and Council Lead

Your design phase is complete. You have ADRs documenting every architectural choice, Mermaid diagrams mapping the system, and an implementation plan with phased dependencies.

Now you populate the system with the 26 agent files that make it work. Each agent is a Markdown template with a strict contract: who it is, what it accepts, what it produces, and how to invoke it. The agents live in your vault as plain files, which means any AI client that can read Markdown can drive the entire pipeline.

In this step, get ready to:
  • Generate all 26 agent files (25 agents across 5 teams plus 1 Council Lead) using any AI client with vault access.
  • Validate completeness with a Dataview query confirming 26 files with all required fields.
  • Test client-agnostic portability by reading the system from a different AI client.
Generate all 25 agents and the Council Lead

The 26 agent files are the operational core of your system. Each file defines a single agent's identity, responsibilities, and interface contract so that any AI client can invoke it without ambiguity.

  • Create the folder structure for all teams by running these commands in PowerShell from your vault root (C:\Users\<username>\Documents\IdeationCouncil):
mkdir Council\agents\team-a, Council\agents\team-b, Council\agents\team-c, Council\agents\team-d, Council\agents\team-e, Council\agents\council-lead
  • Confirm the folders exist by running:
ls Council\agents

You should see six folders listed: council-lead, team-a, team-b, team-c, team-d, and team-e.

Now you need to generate the actual agent files. Each file must contain a specific set of fields that form the agent's contract.

  • Open your preferred AI client with vault access (Claude Desktop via filesystem MCP, Cursor with the workspace open, or any client that can write files to the vault).
  • Provide the following generation prompt to your AI client. This tells it what to create and where to put the files:
# Agent Generation Request

Generate 26 Markdown agent template files in my vault under `Council/agents/`.

## Structure
- `Council/agents/council-lead/council-lead.md` (1 file)
- `Council/agents/team-a/` (5 files: a1.md through a5.md)
- `Council/agents/team-b/` (5 files: b1.md through b5.md)
- `Council/agents/team-c/` (5 files: c1.md through c5.md)
- `Council/agents/team-d/` (5 files: d1.md through d5.md)
- `Council/agents/team-e/` (5 files: e1.md through e5.md)

## Each agent file MUST contain these YAML frontmatter fields:
- agent_id: unique identifier (e.g., "council-lead", "a1-strategist")
- team: which team (council-lead, team-a, team-b, team-c, team-d, team-e)
- subsystem: which of the 4 subsystems this agent belongs to
- reuse_tier: (foundation | cycle | scenario)

## Each agent file MUST contain these body sections:
- **Persona**: Who this agent is and their expertise
- **Input Contract**: What data/artifacts this agent accepts
- **Output Contract**: What this agent produces
- **Frameworks Referenced**: Methodologies this agent applies
- **Invocation Prompt**: The exact prompt template to activate this agent
- **Validation Checklist**: How to verify this agent's output quality
- **Disclosure Template**: EU AI Act transparency statement

## Team Assignments:
- **Team A (Intelligence/Strategy)**: 5 agents for strategic analysis, research, domain expertise
- **Team B (Red Team/Review)**: 5 agents for adversarial review, quality gates, standards
- **Team C (Visual Ideation)**: 5 agents for Excalidraw canvas creation, mind maps, diagrams
- **Team D (Synthesis)**: 5 agents for specs, ADRs, INVEST stories, dependency graphs
- **Team E (Delivery)**: 5 agents for Linear ticket creation, estimation, goal attachment, standards gate
- **Council Lead**: Orchestrator that routes work through Teams A-E in sequence

## Council Lead special fields:
- Orchestration sequence (order of team invocation)
- Routing logic (how to decide which agents within a team to invoke)
- Escalation paths (what happens when an agent fails validation)

What does this prompt do?

This prompt tells your AI client to create 26 files with a consistent structure. The YAML frontmatter makes each file queryable by Dataview. The body sections form a contract that any future AI client can read and execute without needing extra context.

The team assignments map to the 4 subsystems from your architecture diagrams: Team C handles Visual Ideation, Teams A and B form the Intelligence Layer, Team D runs Synthesis, and Team E manages Delivery.

  • Submit the prompt to your AI client and wait for it to generate all 26 files. With Claude Desktop or Cursor, the client writes directly to your vault via MCP or workspace access.
  • If your AI client cannot write files directly (Gemini web, for example), copy the generated content and save each file manually into the correct folder in Obsidian.

Split across multiple clients for speed

One client can generate all 26 files in roughly 8 minutes. If you have multiple clients available, split the work: give Team A and B to one client and Team C, D, E to another. They write to different folders so there are no conflicts.

  • After generation completes, open Obsidian and expand the Council/agents/ folder in the sidebar.
  • Verify you see 6 subfolders each containing their expected files (5 per team folder plus 1 in council-lead/).

Files not appearing in Obsidian?

If the files were written by an AI client via MCP but Obsidian does not show them, click anywhere in the file explorer pane or switch to a different folder and back. Obsidian watches the filesystem but occasionally needs a nudge to refresh.

If you see empty files or files missing sections, re-run the generation prompt for just that team folder. Specify the missing fields explicitly.

Why aren't my generated agent files showing in Obsidian?

Validate agent completeness via Dataview

You need to confirm that all 26 files exist and that each one has the required contract fields. Dataview lets you query your vault like a database, so you can count files and check metadata without opening each one manually.

  • Create a new note in your vault root called agent-validation.md by pressing Ctrl+N in Obsidian.
  • Paste the following Dataview query into the file:
# Agent Validation

## File Count (expect 26)

```dataview
LIST
FROM "Council/agents"
```

## Field Check - Agent IDs

```dataview
TABLE agent_id, team, subsystem, reuse_tier
FROM "Council/agents"
SORT team ASC
```

What do these queries do?

The first query lists every file inside Council/agents/ and all its subfolders. Count the bullet points in the rendered output. You should see exactly 26 items.

The second query pulls the YAML frontmatter fields from each agent file into a table. Any row with blank cells means that agent is missing required metadata. Fix those before proceeding.

  • Save agent-validation.md and switch to Reading View (Ctrl+E toggles between Edit and Reading in Obsidian).
  • Count the items in the first query output. You should see 26 linked file names.
  • Scan the table in the second query. Every row should have values for agent_id, team, subsystem, and reuse_tier.

Seeing fewer than 26 results?

Check that each agent file has YAML frontmatter enclosed in --- fences at the very top of the file. Dataview only reads metadata from properly formatted frontmatter.

If a team folder is empty, re-run the generation prompt targeting only that team. Specify the folder path explicitly so the AI client writes to the correct location.

My Dataview query shows fewer than 26 agents. How do I find which ones are missing?

  • If any fields are blank in the table, open that agent file and add the missing YAML fields. Each agent must have agent_id, team, subsystem, and reuse_tier in frontmatter.
  • Verify that each file's body contains all 7 required sections: Persona, Input Contract, Output Contract, Frameworks Referenced, Invocation Prompt, Validation Checklist, and Disclosure Template.
Test portability with a different AI client

The entire point of client-agnostic design is that the vault works regardless of which AI tool reads it. You prove this by switching clients and confirming the new client can understand the system without any reconfiguration.

  • Pick a DIFFERENT AI client than the one you used to generate agents. If you used Claude Desktop, switch to Cursor, ChatGPT Desktop, or Gemini. If you used Cursor, switch to Claude Desktop or Gemini.
  • Open your vault with that client. For Cursor, open the IdeationCouncil folder as a workspace. For Claude Desktop, it already has filesystem MCP access. For Gemini or ChatGPT Desktop, copy the contents of Council/agents/council-lead/council-lead.md and paste it into the chat.
  • Ask the second client this question:
Read the file Council/agents/council-lead/council-lead.md and summarize:
1. What is the orchestration sequence (which teams are invoked and in what order)?
2. What inputs does the Council Lead expect to start a cycle?
3. What is the final output after all teams complete?
  • Review the client's response. It should correctly identify the team routing order (A through E), the expected input (a brainstorm topic or canvas), and the final deliverable (stories ready for Linear).

What does a passing portability test look like?

If the second client can read and accurately summarize the orchestration sequence, your agent templates are self-documenting. The system is not locked to whichever tool generated the files.

If the client misunderstands the routing or cannot find key information, your templates need more context headers. Add a ## How to Use This Agent section at the top of each file explaining the invocation flow in plain language.

Second client can't access the vault?

For Cursor or VS Code: open the vault folder directly as the workspace. The .cursor/mcp.json and .vscode/mcp.json configs from Step 3 give MCP access automatically.

For Gemini or other web-based clients without file access: copy-paste the Council Lead file content directly into the chat. The portability test still passes if the client can understand the template from the text alone.

How do I give a different AI client access to my Obsidian vault for the portability test?

Your 26 agent templates are deployed, validated, and proven portable. Next up, you will build the Excalidraw canvas templates and governance configuration that feed into these agents during live Council sessions.

Build Excalidraw Canvas Templates and Governance Config

Your 25 agents are deployed and validated. Now you need the surfaces they work on. The Excalidraw canvas is where every brainstorming session begins. It is not decoration. It is the input layer that feeds your entire agent pipeline.

In this step, you will create 7 reusable canvas templates for different brainstorming frameworks, write governance configurations that keep the system consistent across hundreds of cycles, and build stakeholder report templates that format your Council's output for real audiences.

In this step, get ready to:
  • Create 7 Excalidraw canvas templates for different brainstorming frameworks.
  • Write governance YAML schemas and continuous improvement configuration.
  • Build 3 stakeholder deliverable templates for executive audiences.
Create 7 live canvas templates in Obsidian Excalidraw

Each canvas template structures a specific type of brainstorming. When you trigger a Council run later, the agents read from and write to these canvases. The templates give every brainstorm a repeatable visual structure.

  • In Obsidian, right-click the vault root in the file explorer sidebar.
  • Click New folder.
  • Name the folder Canvas.
  • Right-click the Canvas folder and create another folder inside it named templates.

You now have a Canvas/templates/ folder ready to hold your 7 drawing files.

  • Open your preferred AI client with vault access (Claude Desktop, Cursor, or any client that can write files to the vault).
  • Provide the following prompt to generate all 7 canvas templates at once:
Create 7 Excalidraw drawing files in Canvas/templates/ with the following names and structures:

1. mind-map.excalidraw
   - Buzan radial mind map
   - Central node labeled "[CENTRAL TOPIC]"
   - 6 branches radiating outward, each labeled: "Branch 1", "Branch 2", through "Branch 6"
   - Placeholder text on each branch: "[Add sub-topics here]"

2. opportunity-solution-tree.excalidraw
   - Torres Opportunity-Solution Tree
   - Top node: "[TARGET OUTCOME]"
   - 3 opportunity nodes branching down: "Opportunity A", "Opportunity B", "Opportunity C"
   - 2 solution nodes under each opportunity: "Solution 1", "Solution 2"
   - Placeholder text: "[Define measurable outcome]" at top

3. business-model-canvas.excalidraw
   - 9-block Osterwalder Business Model Canvas
   - Labeled regions: Key Partners, Key Activities, Key Resources, Value Propositions, Customer Relationships, Channels, Customer Segments, Cost Structure, Revenue Streams
   - Each region has placeholder text: "[Describe here]"

4. value-proposition-canvas.excalidraw
   - Jobs/Pains/Gains Value Proposition Canvas
   - Left side (Value Map): Products & Services, Pain Relievers, Gain Creators
   - Right side (Customer Profile): Customer Jobs, Pains, Gains
   - Placeholder text in each section: "[List items here]"

5. c4-architecture.excalidraw
   - C4 Architecture Diagram with 3 layers
   - Layer 1 (Context): System boundary with external actors
   - Layer 2 (Container): Internal containers/services
   - Layer 3 (Component): Components within a container
   - Placeholder labels: "[System Name]", "[Container Name]", "[Component Name]"

6. journey-map.excalidraw
   - 5-stage horizontal journey map
   - Stages labeled: "Awareness", "Consideration", "Decision", "Onboarding", "Retention"
   - Each stage has rows for: Actions, Thoughts, Emotions, Opportunities
   - Placeholder text in each cell: "[Describe]"

7. priority-matrix.excalidraw
   - 2x2 priority matrix
   - X-axis: "Low Effort" to "High Effort"
   - Y-axis: "Low Impact" to "High Impact"
   - Quadrant labels: "Quick Wins" (top-left), "Major Projects" (top-right), "Fill-Ins" (bottom-left), "Thankless Tasks" (bottom-right)
   - Placeholder in each quadrant: "[Drag items here]"

Each file should be a valid Excalidraw drawing with labeled regions and placeholder text. Use the Obsidian Excalidraw Markdown format with embedded JSON.

What does this prompt produce?

Your AI client generates 7 .excalidraw files in Markdown format with embedded JSON. The Obsidian Excalidraw plugin stores drawings as Markdown files with YAML frontmatter and a # Drawing section containing the canvas data.

Each template provides a pre-structured visual framework. When you start a Council session later, you copy the relevant template and fill it with your actual brainstorming content.

  • After generation completes, expand the Canvas/templates/ folder in Obsidian's file explorer.
  • Confirm you see all 7 files listed: mind-map.excalidraw, opportunity-solution-tree.excalidraw, business-model-canvas.excalidraw, value-proposition-canvas.excalidraw, c4-architecture.excalidraw, journey-map.excalidraw, priority-matrix.excalidraw.
  • Click on mind-map.excalidraw to open it. You should see a central node with 6 branches radiating outward, each with placeholder labels.

Canvas file not rendering as a drawing?

If the file opens as raw Markdown text instead of a visual canvas, the Excalidraw plugin may not recognize the file format. Check that the file extension is .excalidraw (not .excalidraw.md or .md). Also verify the Excalidraw plugin is still enabled under Settings > Community Plugins.

If your AI client created the files with a different extension, rename them in the file explorer to end with .excalidraw.

Why isn't my Excalidraw file rendering as a canvas in Obsidian?

Why canvas-first instead of text-first?

Most task management systems start with a blank text field. This system starts with a visual canvas because spatial thinking unlocks connections that linear note-taking misses. The canvas IS the intake layer. Everything downstream (agents, stories, tickets) traces back to what you drew.

Write governance YAML schemas and continuous improvement config

Governance files keep your system consistent as you run dozens of cycles. Without them, agent behavior drifts over time. These configs define the rules, identity, and improvement cadence for the entire pipeline.

  • In Obsidian's file explorer, right-click the vault root and create a new folder named Config.
  • In your preferred AI client, provide the following prompt to generate all 6 governance files:
Create 6 governance and configuration files in the Config/ folder:

1. Config/brainstorm-bible.yaml
   - Core governance rules for the Council system
   - Sections: system_principles, quality_gates, naming_conventions, output_standards
   - Include rules for: INVEST story compliance, claim labeling, EU AI Act disclosure, canvas-to-spec traceability
   - Define minimum quality thresholds (e.g., INVEST compliance >= 90%)

2. Config/cycle.yaml
   - Schema for triggering new Council runs
   - Fields: cycle_id, scenario_title, client_used, canvas_template, teams_activated, deliverable_type, linear_initiative_id
   - Include example values showing how to fill it for a new cycle
   - Add validation rules for required fields

3. Config/delivery-systems-identity.yaml
   - System identity and delivery standards
   - Sections: system_name, version, operator_role, delivery_philosophy, quality_bar
   - Define the system as client-agnostic (any AI client can drive it)
   - Include the 4-subsystem architecture reference

4. Config/compounding-loop.md
   - Weekly adversarial review schedule (what to review, which model reviews which)
   - Monthly prompt improvement cadence
   - Quarterly governance review (full system audit)
   - Annual architecture reassessment
   - Include specific actions for each cadence

5. Config/drift-detection.yaml
   - Baseline metrics for detecting system drift
   - Metrics: invest_compliance_rate, canvas_backlink_rate, claim_labeling_rate, cycle_completion_time_minutes, stories_per_cycle_average
   - Set initial baselines (to be updated after first 3 cycles)
   - Define drift thresholds (e.g., > 10% deviation triggers review)

6. Config/run-cycle.md
   - 5-minute operator manual for starting a new cycle
   - Steps: (1) Copy cycle.yaml template, (2) Choose canvas template, (3) Open preferred AI client, (4) Provide Council Lead prompt with scenario, (5) Review outputs, (6) Ship to Linear
   - Written for the operator to follow for the next 100+ cycles without reconfiguration
   - Include troubleshooting tips for common issues

What do these files control?

  • brainstorm-bible.yaml sets the quality rules every agent output must pass.
  • cycle.yaml is the template you copy each time you start a new Council run.
  • delivery-systems-identity.yaml anchors the system's purpose so agents stay on-mission.
  • compounding-loop.md schedules when you review and improve agent prompts.
  • drift-detection.yaml tracks metrics so you notice when quality degrades.
  • run-cycle.md is your quick-start manual for every future cycle.
  • Expand the Config/ folder in Obsidian's file explorer.
  • Confirm all 6 files are present: brainstorm-bible.yaml, cycle.yaml, delivery-systems-identity.yaml, compounding-loop.md, drift-detection.yaml, run-cycle.md.
  • Open run-cycle.md and verify it contains a numbered sequence of steps for starting a new cycle in under 5 minutes.

Files landed in the wrong folder?

Some AI clients create files at the vault root instead of inside Config/. If this happens, drag the files from the vault root into the Config folder using Obsidian's file explorer. You can also re-run the prompt with an explicit instruction like "Place all files inside the Config/ folder at the vault root."

Help me get my AI client to write files to the correct folder in my Obsidian vault.

Write the stakeholder deliverable templates

The Council produces stakeholder-ready reports as its final output for each cycle. These templates define what those reports look like. They give the synthesis agents a consistent format to fill, so every deliverable could be presented to leadership without rework.

  • In Obsidian's file explorer, expand the Specs/ folder and create a new subfolder named templates.
  • In your preferred AI client, provide the following prompt to generate all 3 report templates:
Create 3 stakeholder deliverable templates in Specs/templates/:

1. Specs/templates/executive-migration-roadmap.md
   - For technical leadership audience
   - Sections: Executive Summary, Current State Assessment, Target State Architecture, Migration Phases (Phase 1/2/3 with timelines), Risk Matrix (likelihood x impact), Resource Requirements, Timeline with Milestones, Success Metrics
   - Each section has placeholder text: "[Describe...]" or "[List items...]"
   - Tone: executive-ready, data-driven, concise

2. Specs/templates/content-strategy-brief.md
   - For marketing/audience teams
   - Sections: Positioning Statement, Target Audience Segments, Content Pillars (3-5 pillars with descriptions), Distribution Channels, Editorial Calendar Framework, KPIs and Success Metrics, Budget Considerations
   - Each section has placeholder text guiding what to fill in
   - Tone: strategic, audience-focused, actionable

3. Specs/templates/ai-transformation-proposal.md
   - For client executives
   - Sections: Maturity Assessment (current AI readiness), Opportunity Map (where AI adds value), Implementation Roadmap (quick wins, medium-term, long-term), Build vs Buy Analysis, ROI Model (cost/benefit over 12-24 months), Risk Mitigation, Governance Framework, Next Steps
   - Each section has placeholder text and example structure
   - Tone: consultative, ROI-focused, clear recommendations

Each template should be comprehensive enough that filling it in produces a presentation-ready document. Include guidance comments in each section explaining what content belongs there.

Why pre-built templates instead of free-form output?

Without templates, each Council run produces differently structured reports. Templates enforce consistency so you can compare deliverables across cycles. They also speed up the synthesis pipeline because agents fill sections instead of inventing structure from scratch.

  • Expand Specs/templates/ in the file explorer.
  • Confirm all 3 files are present: executive-migration-roadmap.md, content-strategy-brief.md, ai-transformation-proposal.md.
  • Open executive-migration-roadmap.md and verify it contains clearly labeled sections including Current State Assessment, Target State Architecture, Migration Phases, and Risk Matrix.

Template missing key sections?

If a template is missing sections or has sparse placeholder text, re-prompt your AI client with the specific template name and list the sections you need filled out. Different AI clients have varying levels of detail in their generation. Ask explicitly for guidance comments inside each section explaining what content belongs there.

My stakeholder template is missing sections. How do I get my AI client to generate a more complete template?

Your brainstorming surfaces and governance backbone are in place. You have 7 canvas templates, 6 governance configs, and 3 stakeholder report templates. Next up, you will run your first real Council sessions and watch the full pipeline produce actual deliverables from a live Excalidraw canvas.

Run 3 Real-World Council Sessions

Your vault is fully loaded. 25 agents are ready. Canvas templates are drawn. Governance configs are locked in. Now it is time to prove this system works by running it against real problems.

In this step, you will trigger 3 complete Council sessions, each using a different AI client to prove the system's client-agnostic design. Each session starts with a scenario, produces a live Excalidraw canvas, synthesizes INVEST stories, writes a stakeholder-ready deliverable, and ships tickets to Linear.

In this step, get ready to:
  • Run Session A (Claude Desktop): Azure-to-GCP Cloud Modernization with C4 architecture canvas and Executive Migration Roadmap.
  • Run Session B (Gemini + Codex): Nano Banana Newsletter with mind-map canvas and Content Strategy Brief.
  • Run Session C (Codex): AI-Native Transformation Plan with Business Model Canvas + Value Proposition Canvas and AI Transformation Proposal.
Run Session A: Azure-to-GCP Cloud Modernization

Session A uses Claude Desktop exclusively. The scenario: you are a senior technical manager at an AI company. Cloud build costs on Azure are escalating and leadership wants a migration strategy to GCP.

  • In Claude Desktop, start a new conversation.
  • Paste the following prompt to trigger a full Council run:
# Council Session A: Azure-to-GCP Cloud Modernization

## Context
I am a senior technical manager at an AI company. Our cloud build costs on Azure are escalating and leadership wants a migration strategy to GCP.

## Instructions
Read my vault at the IdeationCouncil root. Use the Council Lead (Council/agents/council-lead/council-lead.md) to orchestrate a full pipeline run.

### Phase 1: Canvas
- Open Canvas/templates/c4-architecture.excalidraw as the base
- Produce a NEW canvas at Cycles/session-a/canvas-c4-azure-gcp.excalidraw showing:
  - Current state (Azure): identity, data pipelines, ML workloads, observability
  - Target state (GCP): equivalent services mapped
  - Migration arrows between layers

### Phase 2: Synthesis
- Write Cycles/session-a/migration-adr.md (Nygard format: why GCP over alternatives)
- Write Cycles/session-a/spec.md with:
  - RFC 2119 language (MUST/SHOULD/MAY)
  - INVEST stories for Phase 1: identity migration, data pipeline cutover, ML workload re-platforming, observability setup
  - Dependency DAG between stories
  - Estimate each story (S/M/L)

### Phase 3: Deliverable
- Use Specs/templates/executive-migration-roadmap.md as template
- Produce Cycles/session-a/executive-migration-roadmap.md
- This must be ready to present to leadership without modification

### Phase 4: Linear Tickets
- Create 10-12 Linear tickets in the Cloud Modernization Initiative
- Each ticket: title from INVEST story, description from spec, estimate label
- Attach all tickets to the Cloud Modernization sub-Initiative

Produce all outputs now. Write files to the vault.

What does the Council produce?

Claude Desktop reads your Council Lead file, which defines the orchestration sequence across Teams A through E. The Council Lead routes the scenario through strategy agents, synthesis agents, and finally the delivery bridge.

The outputs land in Cycles/session-a/ as permanent vault artifacts. The canvas is your visual record of the architectural decision. The spec is the engineering contract. The roadmap is the stakeholder artifact.

  • Wait for Claude Desktop to produce all outputs. This takes approximately 10-15 minutes depending on response length.
  • In Obsidian, navigate to Cycles/session-a/ and confirm 4 files exist: canvas-c4-azure-gcp.excalidraw, migration-adr.md, spec.md, and executive-migration-roadmap.md.
  • Open Linear in your browser and verify 10-12 tickets appear under the Cloud Modernization Initiative.

Claude Desktop hit a usage limit mid-session?

The Free tier has conversation limits that may interrupt long Council runs. If Claude stops generating, you have three options: wait for the limit to reset, continue the same session in Cursor or another client with vault access, or split the prompt into Phase 1-2 and Phase 3-4 as two separate messages.

This is exactly why the system is client-agnostic. The vault state is the checkpoint, not the conversation.

Help me continue my Council session after hitting a usage limit

What if Linear tickets were not created?

If the AI client wrote all vault files but did not create Linear tickets, that is fine for now. Step 7 includes a batch-create and verification pass specifically for this scenario. Focus on confirming the vault artifacts are complete.

Run Session B: Nano Banana Newsletter launch

Session B proves multi-client portability. You will use Gemini for the ideation phase and Codex (via the ChatGPT Desktop App) for refinement and delivery. The scenario: you are launching a newsletter called "Nano Banana" and need a full content strategy.

  • Open Gemini (web at gemini.google.com or the Gemini app).
  • Paste the following ideation prompt:
# Council Session B - Ideation Phase: Nano Banana Newsletter

## Context
I am launching a newsletter called "Nano Banana." I need a full content strategy covering audience segments, content pillars, distribution channels, and monetization.

## Instructions
Produce a mind-map structure (as text/Markdown) with:
- Central node: "Nano Banana Newsletter"
- Branch 1: Audience Segments (3-4 specific segments with demographics)
- Branch 2: Content Pillars (4-5 pillars with example topics)
- Branch 3: Distribution Channels (primary, secondary, growth)
- Branch 4: Monetization (free tier, paid tier, sponsorship model)
- Branch 5: Editorial Calendar (weekly cadence, content types per day)
- Branch 6: KPIs (subscriber targets, open rates, conversion goals)

Format this as a structured outline I can paste into an Excalidraw mind-map canvas.
  • Copy Gemini's mind-map output.
  • In Obsidian, duplicate Canvas/templates/mind-map.excalidraw and save the copy as Cycles/session-b/canvas-mind-map-nano-banana.excalidraw.
  • Open the new canvas in Excalidraw and populate the branches with Gemini's output. Replace all placeholder text with the actual content strategy nodes.
  • Now switch to Codex (ChatGPT Desktop App) and paste the following refinement prompt:
# Council Session B - Synthesis + Delivery: Nano Banana Newsletter

## Context
I have completed ideation for the "Nano Banana" newsletter. The mind-map canvas is at Cycles/session-b/canvas-mind-map-nano-banana.excalidraw in my IdeationCouncil vault.

## Ideation Output (from Gemini)
[Paste Gemini's mind-map output here]

## Instructions
Using the ideation output above and the agent contracts in Council/agents/, produce:

### 1. Content Strategy Spec
- Write Cycles/session-b/content-strategy-spec.md
- Include: positioning statement, content pillars with rationale, distribution strategy, editorial calendar as INVEST stories
- Each story: title, description, acceptance criteria, estimate (S/M/L)
- Target 8 stories covering: launch sequence, first 4 weekly editions, growth experiments, sponsorship outreach, analytics setup, community building

### 2. Stakeholder Deliverable
- Use Specs/templates/content-strategy-brief.md as template
- Produce Cycles/session-b/content-strategy-brief.md
- Ready to share with collaborators without modification

### 3. Linear Tickets
- Create 8 tickets in the Nano Banana Launch Initiative
- Each ticket: title from INVEST story, description, estimate label

Why two clients for one session?

Session B deliberately splits work across Gemini and Codex to prove that no single AI client owns the pipeline. Gemini generates the raw ideation. Codex refines it into specs and tickets. The vault is the handoff layer between them.

If one client is unavailable tomorrow, you swap it out. The files in the vault are the system state, not the conversation history.

  • Confirm Cycles/session-b/ contains: canvas-mind-map-nano-banana.excalidraw, content-strategy-spec.md, and content-strategy-brief.md.
  • Check Linear for 8 tickets under the Nano Banana Launch Initiative.

Codex cannot read files from your vault directly?

If the ChatGPT Desktop App does not have filesystem access to your vault, copy the relevant context (Gemini's output, the template file contents) directly into the prompt. The agent contracts can be summarized rather than read live. The system works with copy-paste as the transport layer when direct file access is unavailable.

Help me adapt the Session B prompt for an AI client without direct file access

Run Session C: AI-Native Transformation Plan

Session C uses Codex (ChatGPT Desktop App) end-to-end for the entire pipeline. The scenario: a client company needs to become AI-powered native and you are proposing the transformation plan.

  • Open a new conversation in the ChatGPT Desktop App.
  • Paste the following full-pipeline prompt:
# Council Session C: AI-Native Transformation Plan for Client

## Context
A client company needs to become AI-powered native. I am proposing the full transformation plan. My vault is at IdeationCouncil.

## Instructions
Run the full Council pipeline end-to-end.

### Phase 1: Canvases
- Create Cycles/session-c/canvas-bmc-vpc-ai-transformation.excalidraw
- Include TWO canvases in one file:
  - Business Model Canvas (9-block Osterwalder): current state vs AI-native target state
  - Value Proposition Canvas (jobs/pains/gains): before AI vs after AI
- Show the transformation delta clearly in each block

### Phase 2: Synthesis
- Write Cycles/session-c/transformation-roadmap.md containing:
  - Build-vs-buy ADR (Nygard format: when to build custom AI vs buy off-shelf)
  - INVEST stories for: AI audit, pilot selection, data readiness, upskilling program, tool procurement, governance framework
  - Each story: title, description, acceptance criteria, estimate (S/M/L)
  - Dependency DAG between stories
  - Timeline (3 phases: Foundation, Pilot, Scale)

### Phase 3: Deliverable
- Use Specs/templates/ai-transformation-proposal.md as template
- Produce Cycles/session-c/ai-transformation-proposal.md
- Executive presentation quality: maturity assessment, opportunity map, implementation roadmap, ROI model
- Must be presentable to client executives without modification

### Phase 4: Linear Tickets
- Create 10 tickets in the Client AI Transformation Initiative
- Each ticket: title from INVEST story, description from roadmap, estimate label

Produce all outputs now.

What makes this session different?

Session C combines two canvas types (Business Model Canvas + Value Proposition Canvas) in a single Excalidraw file. This demonstrates that canvases are not limited to one framework per drawing. The before/after structure makes the transformation visible at a glance.

  • Confirm Cycles/session-c/ contains: canvas-bmc-vpc-ai-transformation.excalidraw, transformation-roadmap.md, and ai-transformation-proposal.md.
  • Check Linear for 10 tickets under the Client AI Transformation Initiative.
  • Open each of the 3 stakeholder deliverables in Obsidian and skim them. Ask yourself: could I present this to a senior leader without rewriting it? If sections feel thin, ask your AI client to expand them.

Outputs are incomplete or missing files?

If the AI client produced partial outputs (wrote the spec but skipped the deliverable, for example), send a follow-up message referencing the specific missing file. Point it at the template path and the existing cycle folder.

If the AI client cannot write files to your vault, have it output the content in the chat, then manually create the files in Obsidian and paste the content in.

Help me get my AI client to produce complete Council outputs

Speed up future cycles

You just ran 3 full Council sessions in approximately 40 minutes total. Each future cycle follows the same pattern: copy Config/cycle.yaml, write a scenario prompt, and trigger. The Config/run-cycle.md operator manual describes the 5-minute startup for your next 100+ cycles.

You have 3 live canvases, 3 stakeholder-ready deliverables, and approximately 30 tickets tracked in Linear. Next up, you will run the Standards Gate across all 3 cycles, batch-verify all Linear tickets, and produce your final system evaluation.

Validate, Ship to Linear, and Produce Final Artifacts

Your 3 Council sessions produced canvases, specs, ADRs, and stories. Now you need to prove the system works end-to-end.

In this step, you run the Standards Gate agent on every cycle to enforce quality, verify that all tickets land in Linear with proper Initiative attachment, and produce your system evaluation scorecard.

In this step, get ready to:
  • Run Standards Gate (E5) on all 3 cycles and write gate reports.
  • Verify ~30 Linear tickets across 3 Initiatives with no orphans.
  • Polish stakeholder deliverables and score the system against 20 requirements.
Run Standards Gate across all 3 cycles

The Standards Gate is your quality control checkpoint. It verifies that every cycle output meets the system's non-negotiable standards before anything ships to stakeholders or gets tracked in Linear.

  • Open any AI client that has access to your vault (Claude Desktop, Cursor, or Gemini).
  • Invoke the E5 Standards Gate agent by referencing Council/agents/team-e/ and asking it to run the gate on Cycles/session-a/.
  • The gate checks 5 criteria: INVEST compliance >= 90%, all claims labeled with source, EU AI Act disclosure present, canvas-to-spec backlinks intact, and reuse-tier tags applied to all outputs.

Use a prompt like this to trigger the gate:

Run the E5 Standards Gate on Cycles/session-a/.

Check the following criteria:
1. INVEST compliance >= 90% on all stories in spec.md
2. All factual claims labeled with source attribution
3. EU AI Act disclosure statement present in the deliverable
4. Canvas-to-spec backlinks (Excalidraw file linked from spec)
5. Reuse-tier tags applied to all reusable outputs

Write the results to Cycles/session-a/gate-report.md.
Flag any blockers that must be fixed before delivery.

What does the Standards Gate check?

INVEST compliance means each story is Independent, Negotiable, Valuable, Estimable, Small, and Testable. The 90% threshold allows minor flexibility on edge cases.

EU AI Act disclosure ensures that any AI-generated content is transparently labeled. This is a governance best practice that makes your system audit-ready.

  • Review the generated gate-report.md in Cycles/session-a/. If any criteria failed, fix the blockers in the cycle files before proceeding.
  • Repeat the same Standards Gate invocation for Cycles/session-b/ and Cycles/session-c/.
  • Confirm that all 3 cycle folders now contain a gate-report.md with passing results.

Run all 3 gates in parallel

If you have multiple AI clients available, run the gate on each session simultaneously. The checks are independent. One client handles session-a, another handles session-b, and a third handles session-c.

Gate report shows failures?

If INVEST compliance is below 90%, ask your AI client to rewrite the failing stories to meet all 6 INVEST criteria. If backlinks are missing, add wikilinks from the spec to the Excalidraw canvas file (e.g. [[canvas-c4-azure-gcp.excalidraw]]).

If EU AI Act disclosure is missing, ask the agent to append a disclosure block to the deliverable stating that AI-assisted generation was used.

Ask for help debugging gate failures.

Batch-create Linear tickets via MCP and verify

Your specs contain INVEST stories that need to become tracked tickets. The Linear MCP connection lets your AI client create tickets directly without switching to the browser.

  • Open the AI client that has an active Linear MCP connection (Claude Desktop or Cursor).
  • Ask the client to read the INVEST stories from Cycles/session-a/spec.md and create Linear issues for each story.
  • Specify that each ticket must include: a title matching the story name, a description pulled from the spec, a time estimate, and attachment to the correct sub-Initiative.
Read the INVEST stories from Cycles/session-a/spec.md.

For each story, create a Linear issue with:
- Title: the story title
- Description: the full story description from the spec
- Estimate: the story point estimate
- Initiative: attach to the "Cloud Modernization" sub-Initiative
- Team: assign to the appropriate team (Strategy or Delivery)

Repeat for Cycles/session-b/content-strategy-spec.md (attach to "Nano Banana Launch" Initiative)
and Cycles/session-c/transformation-roadmap.md (attach to "Client AI Transformation" Initiative).

What does Initiative attachment do?

Initiatives in Linear group related work under a strategic goal. Attaching tickets to an Initiative means you can track progress at the portfolio level. Each of your 3 scenarios maps to one sub-Initiative under the parent "Q3 2026 Delivery Pipeline" Initiative.

  • Wait for the AI client to confirm all tickets are created. It should report the count per Initiative.
  • Open your browser and navigate to your Linear workspace.
  • Click on Initiatives in the left sidebar.
  • Verify that all 3 sub-Initiatives show their tickets.
  • Check that estimates sum to a reasonable total (each story should have 1-8 points).
  • Confirm no orphan tickets exist by checking All Issues and filtering for issues without an Initiative.

Tickets missing or unattached?

If some tickets are missing their Initiative attachment, ask the AI client to update those issues via MCP. Provide the issue identifiers and the target Initiative name.

If the MCP connection dropped during batch creation, restart Claude Desktop (or reload the Cursor workspace) and re-run the prompt for the remaining sessions only.

Get help with Linear ticket issues.

Polish final deliverables and run system evaluation

Your 3 stakeholder deliverables already exist as drafts. This substep is about making them presentation-ready and scoring the entire system against its original 20 requirements.

  • Open Cycles/session-a/executive-migration-roadmap.md in Obsidian.
  • Ask your AI client to review the report for presentation readiness: clear structure, executive summary, actionable recommendations, no placeholder text, and professional tone.
  • Repeat for Cycles/session-b/content-strategy-brief.md and Cycles/session-c/ai-transformation-proposal.md.

What makes a deliverable presentation-ready?

A stakeholder-ready report can be handed to a senior leader, client, or board member without further editing. It has a clear executive summary, concrete recommendations with timelines, identified risks, and no internal jargon or development notes.

The AI client can check for these qualities and flag sections that need tightening. You make the final call on what stays.

  • Once all 3 deliverables are polished, create the system evaluation scorecard by asking your AI client to generate Specs/system-evaluation.md.

Use this prompt to generate the scorecard:

Create Specs/system-evaluation.md scoring this system against all 20 requirements.

For each requirement, provide:
- Requirement name
- Pass/Fail status
- Evidence (specific file path or observable proof)

Requirements to evaluate:
1. 25 agents deployed across 5 teams
2. 4 subsystems with clear boundaries
3. Client-agnostic portability proven with 2+ clients
4. Canvas-first principle enforced
5. Excalidraw live canvases produced for each cycle
6. Linear integration via MCP with goal attachment
7. Standards Gate operational
8. Continuous improvement configured
9. Stakeholder-ready deliverables produced
10. System scales to 100+ cycles without reconfiguration
11. Adversarial cross-model review operational
12. All governance schemas in place
13. ADRs document all architectural decisions
14. Mermaid diagrams visualize system architecture
15. Implementation plan with phases followed
16. Multi-client portability (not locked to one AI)
17. INVEST compliance on all stories
18. Reuse-tier tagging on all outputs
19. Provenance chain maintained
20. EU AI Act disclosure on outputs

Target: >= 98/100 (19/20 minimum pass).
Log the total score and note any requirement that did not pass with a remediation plan.

Why score against 20 requirements?

The scorecard proves your system does what it claims. Each requirement maps to a design decision you made in the ADRs or a capability you built in the agent templates. The evidence column forces specificity. You cannot claim a requirement passes without pointing to the file that proves it.

A score of 98/100 (19/20) is the minimum acceptable threshold. If any requirement fails, the scorecard includes a remediation plan so you know exactly what to fix.

  • Review the generated Specs/system-evaluation.md in Obsidian.
  • Verify that each requirement has a specific file path or observable proof listed as evidence.
  • If any requirement shows as failed, follow the remediation plan to bring it to passing before moving on.

Score below 98/100?

The most common failures are requirement 11 (adversarial cross-model review) if you only used one AI client, and requirement 18 (reuse-tier tagging) if the gate didn't catch missing tags. Both are fixable by running a targeted update on the affected files.

If requirement 3 (client-agnostic portability) fails because you only used one client, go back and run a single agent prompt from a second client to prove portability. The vault is the system. The client is just the interface.

Ask for help improving your score.

Secret mission

Full Practice-Compounding Loop + System Scorecard

Your system works. But does it improve itself? Wire 3-model triangulation where Claude generates, Gemini critiques, and Codex spot-checks. Build a retrospective automation that feeds improvements back into agent prompts quarterly. Then score your entire system against all 20 original requirements, targeting >= 98/100 with documented evidence.

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

This project runs entirely on local files and free-tier cloud services. There are no ongoing costs regardless of which option you choose.

Resources you used:

  • IdeationCouncil Obsidian vault (all 25 agent templates, 7 canvas templates, 3 cycle outputs, governance configs, ADRs, and architecture diagrams).
  • Linear workspace with ~30 tickets across 3 Initiatives (free tier, no cost).
  • Claude Desktop MCP configuration (system-level JSON modification at %APPDATA%\Claude\claude_desktop_config.json).

Keep everything running

No action needed. Choose this if you plan to run your next cycle immediately or continue scaling the system.

  • Your IdeationCouncil vault stays on disk, ready for the next 100+ cycles with no reconfiguration.
  • Your Linear workspace remains active at $0 with up to 250 issues on the free tier.
  • Your Claude Desktop MCP config keeps filesystem and Linear access wired for future sessions.
  • Open Config/run-cycle.md whenever you want to start a new cycle. Pick any AI client and go.

Pause - I'll come back to this later

Free up system resources without losing any work. Everything stays on disk for when you return.

  • Close Obsidian. Your vault files remain on disk and reload instantly when you reopen.
  • Close Claude Desktop if you are not using it for other tasks.
  • Your Linear workspace persists at no cost. Tickets and Initiatives stay intact.
  • When you return, open the IdeationCouncil vault in Obsidian and continue from Config/run-cycle.md.

Delete - I don't want to use this again

Remove all project resources and start fresh. This is permanent.

  • Delete the IdeationCouncil vault by running this command in PowerShell:
Remove-Item -Recurse -Force "$env:USERPROFILE\Documents\IdeationCouncil"
  • Revert your Claude Desktop MCP configuration. Open %APPDATA%\Claude\claude_desktop_config.json in a text editor and remove the filesystem and linear entries from the mcpServers object. Save the file and restart Claude Desktop.
  • Delete your Linear workspace. In Linear, open Settings, scroll to the bottom of General, and select Delete workspace. This removes all tickets, Initiatives, and teams permanently.
  • Confirm the vault is gone by running:
Test-Path "$env:USERPROFILE\Documents\IdeationCouncil"

You should see False confirming the folder no longer exists.

That's a Wrap!

That's a Wrap!

Nice work! You built a local Excalidraw brainstorming tool that manages your entire delivery pipeline. From canvas sketches to shipped tickets, your system turns visual thinking into tracked work.

You've learned how to:

  • Design a production system with Architecture Decision Records, Mermaid architecture diagrams, and an implementation plan before writing a single config file.
  • Build a client-agnostic 25-agent pipeline inside an Obsidian vault with live Excalidraw canvases that any AI client can pick up and run without reconfiguration.
  • Run 3 real-world Council sessions producing stakeholder-ready deliverables (executive migration roadmap, content strategy brief, AI transformation proposal) backed by live canvases and ship ~30 tracked tickets to Linear with Initiative goal attachment.
  • Wire a practice-compounding loop with 3-model adversarial triangulation (Claude generates, Gemini critiques, Codex spot-checks) and produce a system evaluation scorecard scoring >= 98/100 against all original requirements with documented evidence.

Ready to quiz yourself?