The Setup No One Is Getting Right

Most people install OpenClaw, throw a system prompt at it, and wonder why their agents aren't doing anything useful.

I spent weeks rebuilding my setup from scratch. Here's the exact architecture I'm running - the dashboard, the Telegram routing, the model selection, and the prompts.

1. Mission Control - Local Next.js Dashboard

You need a single source of truth. If your agents can't see what's happening, they can't act on it.

I built a kanban-style dashboard in Next.js that runs locally. Every agent reads from this board. It's not a nice-to-have - it's the coordination layer. Without it, agents duplicate work or sit idle.

**Prompt:**

Create a mission control dashboard in Next.js with a kanban-style taskboard. It should update in real-time and serve as the main hub where agents check for available tasks. Include columns for Backlog, In Progress, Review, and Done.

Key design decision: agents check the backlog autonomously. If there's a task in their domain, they queue it and pick it up. No assignment needed.

2. Model Selection - The Part Everyone Overlooks

This matters more than your prompt. Running Claude Sonnet on every agent is how you burn through your Anthropic credits in a week.

Here's my actual split:

| Agent | Model | Why |

| ------------------ | ------------- | ------------------------------------------------- |

| Main Assistant | Claude Opus | Direct chat, complex reasoning, needs to be sharp |

| Content Strategy | Claude Sonnet | Creative work, nuanced writing |

| Content Creation | Claude Sonnet | Scripting, editing, needs quality |

| Project Management | Claude Sonnet | Task coordination, context-heavy |

| Research | Kimi K2.5 | Web search, summarization - doesn't need Sonnet |

| Trend Scanning | Kimi K2.5 | Pattern matching across sources |

| Metrics Tracking | Kimi K2.5 | Data pulling, formatting |

| Finance Tracking | Kimi K2.5 | Price checks, portfolio updates |

| Analysis | Kimi K2.5 | Synthesis tasks |

| Quick Tasks | Gemini Flash | Simple lookups, fast responses |

**5 out of 10 agents run on Kimi K2.5.** It's 5-8x cheaper than Claude for sub-agent work. For tasks like research, trend scanning, and data pulling, you don't need a frontier model - you need a reliable one that won't eat your budget.

The cost stack:

The rule: match the model to the task complexity. Creative and reasoning-heavy work → Claude. Structured retrieval and monitoring → Kimi. Simple ops → Gemini Flash. If you're running Sonnet on a cron job that checks gold prices twice a day, you're lighting money on fire.

3. Telegram Topics - Isolated Agent Contexts

This is the part most people are missing entirely.

One Telegram chat for everything = one giant context window where conversations bleed together. Telegram Topics fix this.

**8 topics = 8 isolated contexts.** Each topic has its own memory file. When I tag my agent in "Content-Sourcing," it scouts and logs to that topic's memory. In "Product-Manager," it updates the taskboard. No cross-contamination.

The routing:

const topicRouter = {
  1: 'general',
  20: 'content-sourcing',
  32: 'product-manager',
  162: 'writing-agent',
};

function routeMessage(topicId, message) {
  const context = topicRouter[topicId] || 'general';
  writeToMemory(context, message);
  updateDashboard(context, message);
}

Memory file structure:

memory/
├── 2026-03-05.md
└── telegram/
    └── topics/
        ├── general-2026-03-05.md
        ├── content-sourcing-2026-03-05.md
        ├── product-manager-2026-03-05.md
        └── writing-agent-2026-03-05.md

Gotcha: Telegram's Bot API treats every topic as a separate chat ID. Your bot needs explicit permissions per topic. Miss one → silent failure, no error message.

4. Heartbeats - Cron-Scheduled Autonomy

Heartbeats are how agents stay proactive instead of reactive. Every interval, the agent wakes up, checks the dashboard, scans its memory, and decides whether to act.

I started at 30-minute intervals. Too aggressive - burning tokens on empty check-ins. Settled on 1-2h for active agents, slower overnight. Research and trend agents can run every 3h since their tasks aren't time-sensitive.

**Prompt:**

Every [interval], check the Mission Control dashboard for tasks in the backlog that match your domain. If a task is available, queue it, update the board to "In Progress," and begin working. If no tasks are available, scan your recent memory for follow-ups worth flagging. Log a brief status update either way.

This is also where model selection compounds. A Kimi agent running a heartbeat every 2 hours costs almost nothing. A Sonnet agent doing the same thing adds up fast.

5. The Full Sync Flow

Telegram message
       ↓
Parse topic ID → route to context
       ↓
Write to topic-specific .md file
       ↓
Dashboard reads memory/*.md → live UI
       ↓
Extract tasks → update taskboard
       ↓
Agent heartbeat picks up task → executes
       ↓
Result logged back to topic memory

Telegram is the interface. Memory files are the brain. The dashboard is the nervous system. Heartbeats are the pulse.

6. Constraints - The Agent Role Prompt

Every agent gets the same structure:

**Prompt:**

You are [role]. Your domain is [specific scope]. You have access to [tools]. Your quality bar is [standard]. You do not work outside your domain - if a task falls outside your scope, flag it in the General topic. Check the dashboard every heartbeat for tasks in your domain. Be proactive, not reactive.

This is where people get it wrong. They think more freedom = better output. It's the opposite. When you constrain the domain, the agent can actually move fast within those walls. And when something breaks, you can isolate the problem because each agent's scope is defined.

An unconstrained agent is a black box. A constrained one you can debug.

What's Next

The layer I haven't covered: **OpenClaw + Obsidian + Claude Code.** That's the knowledge system - how agents access your vault, trace ideas across time, and build on context that compounds. The Telegram setup handles execution. The Obsidian layer handles intelligence.

Next piece.

*Your agents are only as good as the architecture you give them. The model, the routing, the memory structure, the constraints - that's the actual work. Get the setup right and the agents run themselves. Skip it and you're just talking to a chatbot.*