Dashboard logo

Dashboard

OrganizationPopular
openonion
dashboard

Update the agent's Control Center. Use when the user says "update my Control Center", "update my dashboard", "redesign my home", or "/dashboard".

Overview

Publisheropenonion
Repositoryconnectonion
Skill namedashboard
Stars
1.5K
Forks
218
Bundled files
Instructions only
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by openonion on GitHub. Read the source before you install it.

Installation

Install the Dashboard AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/openonion/connectonion.git /tmp/connectonion
mkdir -p .claude/skills
cp -r /tmp/connectonion/connectonion/cli/co_ai/skills/builtin/dashboard .claude/skills/dashboard
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Dashboard in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Dashboard on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Dashboard is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Control Center Skill

The agent's Control Center can be customized through the compatible single file .co/dashboard.html, beside .co/skills/. (Older agents keep theirs in the project root — if dashboard.html is there, that is the one being served: edit it where it is, don't create a second one.) OChat renders it in a sandboxed iframe beside the chat and re-reads it after every run. You edit it with your normal file tools (Read, Edit, Write, Bash) — there is no special API.

Instructions

  1. Read the file first.co/dashboard.html, or the root dashboard.html if that is where this agent's already is — so you preserve its structure and styles before changing anything.
  2. Make the smallest edit that satisfies the request — change the data or add a section; don't rewrite the whole file unless the user asks for a redesign.
  3. Keep it visual, not textual. Lead with state, big numbers, generous whitespace, and clear action buttons. A Control Center is glanceable, not a document.
  4. Write the file and stop. OChat picks up the change automatically after the run.

Action buttons — the one contract

A button that runs something MUST be a real, user-invocable skill, wired like this:

html
<button data-ochat-skill="daily-brief">Build today's brief</button>
  • The data-ochat-skill value is the exact skill name; OChat validates it and runs /daily-brief as a visible chat turn.
  • Optional arguments: data-ochat-skill="meeting-prep" data-ochat-args="2pm sync" → runs /meeting-prep 2pm sync.
  • Use an outcome-oriented label ("Prepare my next meeting"), not the raw skill name.
  • Only reference skills that actually exist. Never invent skill names, and don't add buttons for internal/bootstrap skills.
  • Only project skills work as buttons — the ones in .co/skills/ or .claude/skills/. Your personal skills (~/.co/skills/) and builtin skills aren't published to clients, so a button for one renders but silently refuses to run. Check the skill's location before wiring it up.

Filtering a long list

A Control Center pane that lists thirty skills is a wall. Declare the list filterable and the client renders the box and does the filtering:

html
<co-filter target="#skills" placeholder="Filter skills"></co-filter>
<div id="skills">
  <button data-ochat-skill="daily-brief">Build today's brief</button>
  <button data-ochat-skill="meeting-prep">Prepare my next meeting</button>
</div>
  • target is a CSS selector for the container. Its direct children are what get shown and hidden, so wrap each row in one element.
  • Matching is case-insensitive and anywhere in the row's text.
  • You write the tag; you never write the behaviour. There is no script to add, and adding one would not run.
  • If target matches nothing, no box is rendered — a filter that filters nothing looks like a working control and is not one.

Sorting a table

Declare the table sortable and the client makes its headers clickable:

html
<co-table target="#runs"></co-table>
<table id="runs">
  <thead><tr><th>skill</th><th>runs</th></tr></thead>
  <tbody>
    <tr><td>daily-brief</td><td>128</td></tr>
    <tr><td>meeting-prep</td><td>9</td></tr>
  </tbody>
</table>
  • target is a CSS selector for the <table>. It needs a <thead> and a <tbody>, or nothing is rendered.
  • Do not label the column types. Numbers sort as numbers because the cells are read, not because you said so — $1,200, 30% and 1,000 all count.
  • First click sorts ascending, second descending.
  • Sorting and <co-filter> compose: one reorders, the other hides.

Rules

  • One file: .co/dashboard.html. No sidecar JSON, no build step.
  • It does not exist until you write it. Until then the client shows a built-in starter Control Center — identity/state, Now, quick actions, activity, schedules, searchable capabilities, and diagnostics — rendered fresh each time, so it follows the agent as skills come and go. Writing the file replaces that for good: from then on it is yours, nothing regenerates it, and a skill you add later will not appear until you add its button.
  • Keep it under 2MB — the host won't send a larger file, and the Control Center pane goes blank. Inline images are base64, which is ~33% bigger than the source file, so compress screenshots before embedding them.
  • Keep the responsive layout and prefers-color-scheme dark mode intact.
  • A media query here measures the Control Center pane, not the browser window. The page renders inside its own iframe. The pane is resizable, roughly 320–900px, so design for the narrow end: a four-column table needs about 500px, and below that the column the table exists for ends up off the right edge behind a scrollbar. Give wide tables a stacked form for narrow panes.
  • Do not add <script> tags or inline onclick handlers — OChat strips all scripting. Interactivity comes from the declared tags (data-ochat-skill, <co-filter>, <co-table>), which the client renders for you.
  • Keep styles inline in the file (external URLs are blocked in the sandbox).
  • No links out. A Control Center is one self-contained page. Don't add <a href="https://…"> — the client cancels those clicks, so the link renders as dead text. Same-page anchors (href="#section") work fine. If you want the user to do something, that's what a data-ochat-skill button is for.

Frequently asked questions

What does the Dashboard AI skill do?

Update the agent's Control Center. Use when the user says "update my Control Center", "update my dashboard", "redesign my home", or "/dashboard".

Why use Dashboard on TypingMind?

Because you install it once and use it with any model. Dashboard is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Dashboard in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/openonion/connectonion/tree/main/connectonion/cli/co_ai/skills/builtin/dashboard. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Dashboard?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Dashboard?

As many as you like. As long as a model supports skills, you can use Dashboard with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Dashboard AI skill free?

Yes. It is published on GitHub by openonion under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇