A working multi-agent system for your organization in one sitting. You will leave with agents, state files, memory, and a first session that reads your real data.
15-minute window before the workshop starts. Do this while attendees arrive and grab coffee.
claude.ai/download — free client, macOS/Windows/Linux. If not installed, use claude.ai in a browser as fallback.claude.ai/download covers basics.git clone https://github.com/ShdwSpde/spark-workshop-templateWalk the room during this 15-min window. Your one job before Hour 1 starts: every attendee has Claude Code open, a terminal open, and the template repo cloned. If one person is behind at the start of Hour 1, they spend the whole workshop catching up. Solve setup first.
On a sheet or a blank markdown file, list every role your organization needs but can't afford. Not titles — functions. Who writes the grants? Who designs the lesson? Who checks the cultural accuracy? Who follows up with partners? Who tracks decisions?
Target: 5–10 roles. 3 minutes.
Group-share after 3 min. Write the roles on a whiteboard or a shared screen. Call out the patterns: nearly every nonprofit lists Grant Writer, Content/Comms, Research/Archivist, Reviewer, Operations. The pattern is the point — those are their agents.
Walk through the four things every agent needs. Keep this tight — the build session is where it lands, not here.
| Property | What it means | Example |
|---|---|---|
| Scope | What this agent handles (and does not) | Grant strategy, funder analysis, pricing — not commercial opportunity alignment |
| Intent signals | Keywords that route to this agent | grant, funding, LOI, investor, SAFE, deadline |
| Voice | How this agent communicates | Blunt. Numbers-aware. Reads rejection letters for fun. |
| Calibration | Conservative (false negatives preferred), Aggressive (false positives preferred), Balanced | Aggressive — include long-shot funders; better to surface a bad fit than miss a good one |
Show a real agent spec on screen — open agents/example-grant-writer.md from the template. Point out: it's ~100 lines. It's plain English. It's markdown in a git repo. It is not magic. That demystification is the lever.
Key line to say out loud: "Agents are personas, not separate programs. Same AI, different hats." This is the idea most people get stuck on.
Pick 3 agents from your warm-up list. For each, fill out the template below as a new file in agents/your-agent-name.md. Name them something that feels alive — The Scout, The Librarian, The Editor. Naming matters. The agent feels real when it has a name.
## Agent: [Name] **Scope:** [what this agent handles] **Intent signals:** [keywords that route to this agent] **Voice:** [how this agent communicates — 1–2 sentences] **Calibration:** conservative | balanced | aggressive - Reason: [why this calibration for this role] **Files to read:** [state files this agent depends on] **Files to write:** [state files this agent updates] **Handoff block:** [when this agent finishes, who reviews next?]
Walk the room. Two things to watch for:
2–3 volunteers share their agent rosters. Group gives feedback on naming, scope, and calibration. Keep the energy high — this is the first time attendees hear their own ideas mirrored back.
One sentence to say: "If your AI forgets everything between sessions, it's not a colleague — it's a stranger you brief every morning. The state layer is what turns it into a colleague."
Show the file tree. Every agent reads the same files. Every agent writes to them. No database, no vendor lock-in. Just markdown in a git repo.
Walk through the 4 files every Spark needs. Keep each to 2 minutes — they'll populate them next.
| File | What it holds | Who writes to it |
|---|---|---|
state/org-state.md | The map. Current priorities, active projects, upcoming deadlines. 80 lines max — if it's longer, archive. | Every agent at session close |
state/portfolio.md | Every project — status, owner, health, links. The "what exists" doc. | Collective Manager agent |
state/last-session.md | 15 lines that give next session a running start. What shipped, what's blocked, what's next. | Whichever agent closed the last session |
state/decision-journal.md | Every non-trivial decision with reasoning, alternatives, confidence, reversibility. | Any agent making a decision |
Show one real decision-journal.md entry on screen. People light up when they see it's just plain English with a confidence score. The bar for authoring one is low. The benefit is compounding — six months from now when someone asks "why did we choose this?", the answer is searchable.
Create the four files below. Populate them with your real data — not placeholders. The portfolio is the hardest. Most people have never written all their projects in one place. Do it now. 20 minutes on portfolio.md, 10 minutes on the rest.
--- version: 1 last_modified: YYYY-MM-DD --- # [Org Name] — State ## Top 3 Priorities This Week 1. [priority + why + by when] 2. [priority + why + by when] 3. [priority + why + by when] ## Active Projects (live status only) - [Project A] — [1-line status] — owner: [name] - [Project B] — [1-line status] — owner: [name] ## Upcoming Deadlines (next 30 days) - YYYY-MM-DD · [what's due] · [who owes what] ## Open Decisions - [decision being considered + confidence level] ## Stale Flags - [files not updated in 7+ days]
# Portfolio | Project | Status | Owner | Next Milestone | Link | |---------|--------|-------|----------------|------| | [Name] | active / paused / shipped / parked | [who] | [what + when] | [URL] | | [Name] | ... | ... | ... | ... | ## Status Definitions - **active** — work this week - **paused** — will resume; reason logged - **shipped** — released and in maintenance - **parked** — may revive; keep minimal upkeep only
# Last Session — YYYY-MM-DD ## Shipped - [one line per thing] ## Blocked - [thing + what's blocking + who unblocks] ## Next Session - [one priority + why]
# Decision Journal ## YYYY-MM-DD · [Decision in one line] - **Chose:** [option] - **Alternatives:** [options considered + why rejected] - **Reasoning:** [why this one] - **Confidence:** N/5 - **Reversible:** yes / no / partially - **Owner:** [who] - **Status:** active / superseded / retired
Walk the room every 10 minutes. Most people stall on the portfolio — they realize they have 12 things active and hadn't admitted it. That stall is productive. Don't rescue them. Let them write it all down. That's the workshop doing its job.
Create memory/MEMORY.md with 3 seed memories. One of each type:
# Memory Index ## User - [user_communication_style.md] — one-line hook ## Project - [project_[name].md] — one-line hook ## Feedback - [feedback_[topic].md] — one-line hook
Each entry in the index points to a standalone file with the full memory. Keep the index short — it loads every session.
Live demo. Connect Gmail MCP to Claude Code. Show: search email, read a thread, create a draft. The rule every attendee needs to hear out loud:
Drafts only. Never sends. Tone is personal. Relationships are human. Sent emails can't be unsent. The AI drafts better than you'd write from cold — because it has your state context. But the human sends.
Connect your own Gmail if you're ready. If the OAuth flow is flaky, skip — you can do it after the workshop. Connection isn't the point. Seeing the draft come out is.
Walk through how every session should start and end. The protocol is the discipline — without it, the system drifts.
1. Read state/org-state.md 2. Read state/last-session.md 3. Scan memory/MEMORY.md 4. Check for contradictions (portfolio vs validation-log, etc.) 5. Flag deadlines ≤7 days 6. Flag state files stale >7 days 7. Brief the human: what's loaded, what's flagged, what's first.
1. Update state files that changed 2. Log any decisions made 3. Draft morning email (review & send) 4. Write next session's first prompt into last-session.md 5. Commit + push 6. Done. Close the terminal.
The hardest sell here isn't technical — it's the every session part. Participants nod during the workshop and then skip it on Monday. Call it out: "The protocol is why this works. Skip the close checklist once and you'll be debugging stale state a week later."
This is the moment. When the AI reads the attendee's own data and responds with intelligence about their organization, it clicks. Nothing you can say in Hour 1 or 2 replaces this.
"What's the status of my projects?"portfolio.md and respond in the voice of your first agent."Draft an email to [real person] about [real project]. Warm but direct."Walk the room. You're watching for the face. The moment someone's AI responds to their real org data, their face changes. Catch it. Name it. Ask them: "What just surprised you?" That answer is the testimonial.
If someone's session isn't working — 9/10 times the CLAUDE.md isn't pointing to the state files, or the state files are empty. Check those two.
Before we close, the truth about what you just built. Every connector you wired into this system — Gmail, Drive, your newsletter platform — is a permission someone else can revoke. The math is brutal:
14 connectors × 95% reliability = 49% daily success rate. Five connectors gets you to 77%. Three to 86%. Compounding failure is the actual ceiling on agentic AI for non-power users — the population that is most of the population.
Three responses, in order of difficulty:
This module is uncomfortable on purpose. Don't soften it. Don't apologize for it. The truth here is what builds trust the other AI workshops can't buy.
If a connector is currently broken in your own setup — show it. Pull up the error. Say "this happens to me. it happens to every team. it's not your fault when it happens to you."
Close with the political beat: "Every connector is a permission someone else can revoke. Your member list, your archive, your inbox — none of it is yours if Google decides tomorrow it's not. Agentic AI is only as autonomous as the stack underneath it. Other AI workshops are selling the magic. We're selling the discipline."
Bridge to RI: "If running this stack alone feels heavy — that's correct. RI runs a managed ops tier. Talk to us after."
The last 10 minutes are the highest-leverage 10 minutes in the workshop. Ask these three questions out loud, in order. Give people 30 seconds to think before answering. Write the answers down or have everyone drop them in a shared Google Form.
Q1 gives you outcomes. Q2 gives you the next workshop iteration. Q3 gives you the testimonial wall.
Close the workshop with one line:
"You just built the skeleton. The muscle grows every session you use it. Go run your first real session tonight."
Spark is a pattern — specialized agents + shared markdown state + persistent memory + session protocol. The pattern is more important than the tool. Here's how to get 60–95% of it with something else, and what you give up.
Works with Anthropic, OpenAI, Gemini, local models via Ollama, or anything OpenAI-compatible. Reads/writes files, runs terminal commands, supports MCP servers. Essentially Claude Code without the desktop app wrapper.
Runs in your terminal. Auto-commits every change with a readable message. Supports Claude, GPT-4, Gemini, local models. The git-native discipline Spark needs is baked in by default.
Projects give you persistent context per-folder. Custom GPTs let you define agent personas. File upload for state. Works without any local setup.
Excellent for file reading and editing. Agent mode can run commands. Supports Claude, GPT, Gemini. Great for developers who want the IDE experience and are already coding.
Ships with a generous free tier. Reads files, runs commands, has a built-in tool system. If your org lives in Google Workspace, the Google Docs / Drive / Calendar integration pulls through naturally.
Maximum flexibility. Define agents as code, route between them with graphs, run locally or on your infra. Every major pattern (handoffs, memory, tool use) is configurable.
| Capability | Claude Code |
Cline | Aider | ChatGPT Projects |
Cursor | Gemini CLI |
LangGraph /Crew |
|---|---|---|---|---|---|---|---|
| Reads local files | ● | ● | ● | — | ● | ● | ● |
| Writes local files | ● | ● | ● | — | ● | ● | ● |
| Runs terminal commands | ● | ● | ◐ | — | ● | ● | ● |
| MCP servers | ● | ● | — | — | ◐ | ◐ | ◐ |
| Persistent memory (cross-session) | ● | ◐ | ◐ | ◐ | — | ◐ | ● |
| Git-native commits | ● | ◐ | ● | — | ◐ | ◐ | ◐ |
| Multi-agent routing | ● | ◐ | ◐ | ◐ | — | ◐ | ● |
| Free or low-cost tier | ◐ | ● | ● | ◐ | — | ● | ● |
| Runs without coding | ● | ◐ | — | ● | ◐ | ◐ | — |
● full support · ◐ partial / setup required · — not supported
| If you are… | Start with… | Why |
|---|---|---|
| A solo nonprofit leader, non-technical | Claude Code | Lowest setup, MCP ecosystem handles Gmail + Calendar out of the box. $20/mo covers it. |
| A solo founder with API-level budget concerns | Cline + Gemini API | Free tier API + open-source client. Same capabilities, 80% of the polish, $0–$5/mo. |
| A developer already living in the terminal | Aider | Git-native by default. The session discipline Spark preaches is automatic here. |
| A team of 2–3 engineers | LangGraph or CrewAI | You have the skill to build. You'll want the control. The ceiling is higher than any managed tool. |
| Someone allergic to terminals | ChatGPT Projects + Custom GPTs | Browser-only. You lose file-system ops, but the agent-persona + persistent-context pattern still works for planning, drafting, research. |
The architecture is the point, not the tool. Markdown state files live in any repo. Agent specs are plain text. The session protocol is a checklist. You can build a Spark on any stack that reads and writes files. Claude Code is the fastest path in 2026 — not the only path.
Context, contingencies, and the stuff that only matters on the day.
| Question | Short answer |
|---|---|
| "Can I use GPT / Gemini instead of Claude?" | Yes. The pattern works with any LLM that has tool use. Claude Code is recommended because MCP integrations are built-in. |
| "Does this work for a team, not just a solo founder?" | Yes. Each member gets their own Spark; state files are shared via git. Federated agents, shared institutional memory. |
| "What if I'm not technical?" | The workshop requires basic comfort with a text editor and terminal. No coding. |
| "Is this the same as using ChatGPT?" | No. ChatGPT forgets between conversations. Spark has persistent state, memory across sessions, multiple agent personas, and tool integrations. Stranger vs. COO. |
| "How much does it cost to run?" | ~$20/month for Claude Pro. MCP integrations (Gmail, Calendar, Drive) are free via OAuth. Git repo is free. |
decision-journal.md template — put it in the follow-up email instead.CLAUDE.md with their org's instructions