I'll be honest about why this happened. Someone posted a Notion dashboard on X. Six AI agent cards, clean layout, color-coded roles. "My Mission Control for managing AI agents." It had 31K views. I saw it and my brain lit up. Not competition. Novelty. It looked fun. It looked organized. It was visual, and visual is how my ADHD brain locks on.

That's the truth. Not some carefully planned initiative. Just a guy with ADHD on a Tuesday night seeing something that looked cool and thinking, "I want to build that."

Two hours later, I had 16 Obsidian Canvas files and a new page on my website. Here's how.

The Problem with "Organized"

I've been running OpenClaw for weeks. 45+ cron jobs. A knowledge graph in Neo4j. Daily self-scoring. Storm monitoring crons. An entire memory architecture with vault indexing and backlink audits. But I had no visual map of any of it. Everything lived in markdown files and JSON configs. If you asked me to draw the system architecture, I'd have to think about it for ten minutes.

That Notion dashboard made the gap obvious. The person had six agents and a visual org chart. I had a sprawling system with no picture of itself. The irony of building a system that can't see its own shape.

3 Messages, 3 Sub-Agents, 16 Canvases

Here's the part that still feels a little unreal. I didn't build 16 canvas files. I described what I wanted in three messages, and my agent spawned three sub-agents that ran in parallel. Each sub-agent picked up 4-5 canvas files and built them simultaneously.

The first message covered the core system canvases: architecture overview, agent org chart, cron schedule heatmap, memory architecture, ecosystem map. The second covered strategy: content pipeline, revenue roadmap, brand identity. The third was everything else: decision trees, financial overview, project maps, vendor relationships, trip planners, family tree.

Total time from first message to all 16 files validated: under 15 minutes. The full session including the /team page took about two hours, but most of that was iteration on the website, not the canvases.

The delegation pattern looked like this:

Me: "Build these 13 canvases. Here are the specs."
    ├── Sub-agent 1: system architecture, org chart, cron heatmap,
    │                memory architecture, ecosystem map
    ├── Sub-agent 2: content strategy, revenue roadmap, brand identity
    └── Sub-agent 3: decision trees, financial overview, project maps,
                     vendor web, trip planners, family tree

Three agents, running at the same time, each producing complex structured output. I watched the files appear in my Obsidian vault one by one.

What a Canvas File Actually Is

Obsidian Canvas uses a JSON format. Each file defines nodes (cards with text, colors, positions) and edges (connections between cards with labels). A simple canvas might have 5 nodes. The system architecture canvas has 30+ nodes across multiple layers with color-coded groupings and directional edges showing data flow.

{
  "nodes": [
    {
      "id": "agent-core",
      "type": "text",
      "text": "## OpenClaw Agent Core\nClaude Opus 4\nMain session + isolated crons",
      "x": 0, "y": 0,
      "width": 280, "height": 160,
      "color": "1"
    },
    {
      "id": "memory-layer",
      "type": "text",
      "text": "## Memory Layer\nSOUL.md / MEMORY.md / Daily logs\nVault index (SQLite FTS5)",
      "x": 0, "y": 220,
      "width": 280, "height": 160,
      "color": "4"
    }
  ],
  "edges": [
    {
      "id": "edge-1",
      "fromNode": "agent-core",
      "toNode": "memory-layer",
      "label": "reads/writes"
    }
  ]
}

Each sub-agent had to understand this format, design a meaningful layout with spatial logic (not just random positions), choose color codes that communicated hierarchy, write connection labels that actually explained relationships, and produce valid JSON that Obsidian could render without errors.

Most of them did. Most.

What Broke

Let's not pretend this was clean.

Two canvases had overlapping nodes. The sub-agent calculated positions that looked fine in isolation but created a pileup when rendered. Obsidian doesn't auto-layout, so overlapping nodes just stack on top of each other and you get an unreadable mess. I had to manually adjust about 15 node positions across two files.

One canvas had an edge pointing to a node ID that didn't exist. A typo. "toNode": "revenue-streams" when the actual node was "revenue-stream". Obsidian silently drops invalid edges, so the connection just vanished. Took me a few minutes to spot it.

The cron schedule heatmap was the most ambitious canvas. It maps all 45+ cron jobs across a 24-hour timeline with color coding by category (monitoring, scoring, content, maintenance). First version was technically correct but visually chaotic. Too many nodes, no grouping, no whitespace. It took a second pass with explicit layout instructions to make it readable.

And honestly, some of the canvases are just okay. The family tree and trip planners are functional but not beautiful. The system architecture and memory architecture canvases are genuinely useful. Not every output was a winner, and I want to be clear about that.

The /team Page

While the canvas sub-agents were running, I started on something else: a /team page for doss.me showing the "team" behind the site. Which is me and my AI agent, plus all the cron jobs and tools that make everything run.

I wanted a specific visual effect I'd seen from @jh3yy on X. Glowing cards that respond to cursor movement. The technique is deceptively simple: you duplicate the card element, blur it heavily, and crank the saturation.

.card-glow {
  position: absolute;
  inset: 0;
  filter: blur(28px) saturate(5) brightness(1.3);
  opacity: 0.6;
  z-index: -1;
  transition: opacity 0.3s;
}

.card:hover .card-glow {
  opacity: 1;
}

The blurred duplicate sits behind the card. On hover, it brightens. The result is a soft, colored glow that bleeds out from the card edges. It looks like the cards are lit from within. Total CSS, no JavaScript required for the basic effect (though the cursor-following version uses a bit of JS to update a CSS custom property for the glow position).

The /team page lists every "team member": the main agent, the scoring engine, the content pipeline, the monitoring stack, the knowledge graph. Each card has a role, a status indicator, and that glow effect. It's theatrical, sure. But it communicates something real: this is a system, not a chatbot.

Why This Matters More Than It Looks

Sixteen canvas files are not, by themselves, impressive. You could build them manually in an afternoon. The point is not the output. The point is the workflow.

I described 13 canvases in 3 messages. My agent parsed the specs, decided how to split the work, spawned 3 sub-agents, and coordinated the output. I didn't manage the sub-agents. I didn't check on them. I went and worked on the /team page CSS while they ran. When I came back, the files were in my vault.

The real power of agentic AI isn't chatting. It's delegation at scale. When you can describe what you want and spawn sub-agents that each build complex deliverables in parallel, you stop thinking in tasks and start thinking in systems.

This is a fundamentally different relationship with a tool. I didn't use AI to "help me write" a canvas file. I described a system of deliverables and let the agent figure out execution. The difference is the same as the difference between typing a document and managing a team.

Most people are still in the typing phase. Asking one question, getting one answer, asking another question. That's fine for some things. But when you need 16 structured files that all share a design language, that approach doesn't scale. Delegation does.

The Honest Part

I built all of this because I saw something visual and organized and my ADHD brain said "yes, that, now." There was no roadmap item called "build visual maps." No sprint ticket. No quarterly goal. Just novelty-seeking and a Tuesday night. If you have ADHD, you know the feeling. Something clicks and you're already building before the rational brain catches up.

And you know what? The canvases are actually useful now. I open the system architecture canvas when I'm explaining OpenClaw to someone. The cron heatmap helped me spot three jobs that were scheduled too close together. The memory architecture map revealed a circular dependency I hadn't noticed in the markdown.

Sometimes the best work comes from chasing novelty. My brain grabbed onto something shiny and fun, and I ended up building something I actually needed.

Sometimes you build the right thing because it looked fun. The canvases started as dopamine. They turned into the first real documentation my system ever had.

The Numbers

• 16 Obsidian Canvas files
• 3 sub-agents running in parallel
• ~15 minutes for all canvas files
• ~2 hours total including /team page and iteration
• ~$2.50 estimated API cost (3 Opus sub-agent sessions + main session)
• 2 canvases with overlapping nodes (fixed manually)
• 1 broken edge (typo in node ID)
• 1 chaotic heatmap that needed a full redesign pass

What I'd Do Differently

Give each sub-agent a validation step. "After generating the canvas JSON, parse it yourself and check for: overlapping nodes within 50px, edge references to non-existent node IDs, and any node positioned beyond x=2000 or y=2000." That would have caught all three issues automatically.

Also: start with a shared design spec. I gave each sub-agent independent instructions, which meant the color coding wasn't perfectly consistent across canvases. Canvas 1 uses color "1" for primary systems, canvas 2 uses color "1" for headers. A shared style guide passed to all sub-agents would have fixed that.

The delegation model works. The coordination layer needs work. That's the next thing to build.