Skip to content
Get packs

Guide · Agent skill

How to use the Building Axiom Dashboards agent skill

Updated · written with AI from the project's own documentation and checked against our catalogue data

The building-dashboards skill teaches an AI agent how to design and build dashboards in Axiom, a logging and metrics platform, through its API. It is for engineers who want a structured oncall or service dashboard, and for teams moving dashboards over from Splunk or Grafana. After this guide you will know what the skill does, how to install it, how to phrase requests so the agent uses it, and what it needs to run.

Building Axiom Dashboardsopenclaw/clawhub · MIT

Quick start

  1. 1Download and unzip the skill. Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use or into a project's .claude/skills/ folder for one repository. You can also upload the ZIP under Settings, Capabilities, Skills in the Claude apps.
  2. 2Set up Axiom access. Create an Axiom account, generate an API access token for the deployment you want to target, and create the ~/.axiom.toml file as described in the README.
  3. 3Confirm the companion skills and tools. Make sure axiom-sre and query-metrics are available, and that jq and curl are installed on your machine.
  4. 4Ask for a dashboard in plain language. Describe the service or migration, the audience and the decision the dashboard should support. Name Axiom so the agent loads the skill.
  5. 5Review the result. Check the dataset kind the agent detected, the panel queries it wrote, and any Note panels that explain blocked panels before you rely on the dashboard.

What does the building-dashboards skill make the agent do?

An agent skill is a folder of instructions (a SKILL.md file plus reference files and scripts) that an AI agent loads when a task matches the skill's description. This one covers creating Axiom dashboards. Instead of improvising, the agent follows a playbook: it asks what decision the dashboard should support, checks whether the data is events/logs or metrics, discovers the available fields, and then designs panels.

The playbook uses a four-level blueprint for events and logs: at-a-glance stat panels such as error rate and p95 latency, trend charts that show what changed, breakdowns (top-N tables or pies) that show where to look, and evidence panels with raw log streams. Metrics datasets follow a parallel blueprint built on the MPL query language. The skill can also translate existing Splunk or Grafana dashboards into Axiom equivalents.

  • Asks for the audience and decision before building anything
  • Discovers schema first instead of guessing field names
  • Uses APL for events/logs and MPL for metrics datasets
  • Replaces any panel it cannot compute exactly with a Note explaining the blocker

How do you install the building-dashboards skill?

Download the skill ZIP from this page and unzip it. For a personal setup, place the unzipped folder in ~/.claude/skills/. For a single project, place it in that project's .claude/skills/ folder. Claude will then find the skill the next time it starts a relevant task.

If you use the Claude apps instead, upload the ZIP under Settings, then Capabilities, then Skills. The project's README also lists an install command (npx skills add axiomhq/skills) that pulls in the skill's dependencies; use that route only if you are comfortable running it.

  • Personal: ~/.claude/skills/building-dashboards/
  • Project: .claude/skills/building-dashboards/ inside your repository
  • Claude apps: Settings, then Capabilities, then Skills, then upload the ZIP

What do you need before the skill can work?

The skill talks to your Axiom deployment through its API, so you need an Axiom account and an API access token for the deployment you want to target. The README says to create a ~/.axiom.toml configuration file; check the README for the exact fields it expects.

The skill depends on two companion skills: axiom-sre, which handles API access and schema discovery, and query-metrics, which handles metrics dataset, metric and tag discovery. The skill also needs the command-line tools jq and curl. The README notes that the install command includes these dependencies, and that query-metrics is also vendored locally in scripts/metrics/.

  • Axiom account and API access token for the target deployment
  • ~/.axiom.toml configuration (see README)
  • axiom-sre and query-metrics skills (included with the npx install route)
  • jq and curl available on your PATH

How do you trigger the skill with a natural request?

You do not need special syntax. The skill's description says it applies when you are creating dashboards, migrating from Splunk, or configuring chart options, so describe the outcome you want in plain language and name Axiom. Mentioning the service, the audience and the decision you need to make gives the agent what its intake step asks for.

Say what kind of dashboard you need and who will use it. If you have an existing Splunk or Grafana dashboard, paste its queries or attach its export and say you want it moved to Axiom.

  • "Build an oncall triage dashboard in Axiom for my checkout service."
  • "Migrate this Splunk dashboard to Axiom and keep the same panels."
  • "Convert these Grafana PromQL panels to Axiom MPL charts."
  • "Configure the unit and sparkline options for my p95 latency panel in Axiom."

How does the agent choose between APL and MPL?

The first technical step is checking the dataset kind. The skill runs scripts/metrics/datasets against your deployment and reads the kind field. A metrics dataset (kind otel:metrics:v1) follows the MPL path. Any other kind is treated as events or logs and follows the APL path, where the agent discovers fields with a getschema query over a time window.

The skill warns that getschema returns zero rows without an error on metrics datasets, so the agent should not use it there. On the metrics path, the agent runs metrics-spec before writing any MPL query, and it validates every pipeline with mpl-validate-chart before the dashboard is created.

  • Metrics dataset: MPL path, metrics-spec before queries
  • Events or logs dataset: APL path, discover fields with getschema
  • Panels that cannot be computed exactly become Note panels instead of approximations
scripts/metrics/datasets <deploy> ['dataset'] | where _time between (ago(1h) .. now()) | getschema

What safety points should you know about?

This skill runs scripts and uses the network. It calls your Axiom deployment through its API, and it creates and updates dashboards there. Give it a token scoped to the deployment you intend to change, and review what it creates before sharing the dashboard with others.

The skill's SKILL.md refers to Axiom CLI scripts under scripts/metrics/ and related helper scripts, but those scripts are not included in the listed files for this package. Check that the scripts are present and that you have read them before running the skill. The skill also says its workflow depends on Axiom's scripts and dataset structure, so it will not work against a non-Axiom system.

  • It runs local scripts and makes network calls to your Axiom deployment
  • Use a token scoped to the target deployment
  • Confirm the referenced scripts exist and review them before first use
  • Review created dashboards before sharing them

What tips help you get better dashboards?

Ask for one decision per dashboard. The skill's design rules favour overview first, then drilldown, then raw evidence, and they prefer rates and percentiles (p95, p99) over averages, because averages hide problems. Simple panels with one question each are easier to act on than dense charts.

When a panel cannot be computed as requested, the skill does not swap in a different number. It writes a Note explaining the blocker and what would unblock it. Treat those Notes as open work rather than something to ignore.

  • Start every request with the decision the dashboard supports
  • Prefer p95 and p99 over averages for latency
  • Expect Note panels for anything that cannot be computed exactly
  • For sparse metrics, the metrics path may need a wider time window; the skill documents when this is acceptable

What people use it for

  • Building an oncall triage dashboard with error rate, p95 latency, request rate and a raw error log panel for one service
  • Migrating a Splunk dashboard to Axiom by extracting its searches, translating them and mapping each to a chart type
  • Converting Grafana PromQL panels into Axiom MPL charts using the Grafana migration reference
  • Adjusting chart options such as units, sparklines and TimeSeries rendering on an existing Axiom dashboard

Frequently asked questions

How do I install the building-dashboards agent skill?

Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use, or into .claude/skills/ inside a project. In the Claude apps, you can instead upload the ZIP under Settings, then Capabilities, then Skills.

Is the building-dashboards skill free to use?

The skill is published under the MIT licence. You still need an Axiom account and an API access token for the deployment you want to target, and the licence terms of Axiom itself apply to that account.

What does the skill need to run?

It needs an Axiom account with API access, a ~/.axiom.toml configuration, the axiom-sre and query-metrics companion skills, and the jq and curl command-line tools. The referenced scripts under scripts/metrics/ must also be present.

Can the skill migrate Splunk or Grafana dashboards?

Yes. For Splunk, it extracts the SPL, translates it to APL with a spl-to-apl step, and maps each panel to a chart type. For Grafana, it translates PromQL to MPL and maps the panels to chart types.

Does it work with tools other than Axiom?

No. The workflow depends on Axiom's scripts, API and dataset structure. If you use another logging or metrics platform, this skill will not build dashboards for it.

What happens if a panel cannot be computed exactly?

The skill does not approximate it or substitute a different quantity. It replaces that panel with a Note that states the blocker, the original spec and what would unblock it.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use this skill if you work with Axiom, especially if you are on oncall and want a consistent triage dashboard or you are moving dashboards from Splunk or Grafana. Pick something else if you do not use Axiom, or if you need a tool that approximates numbers that cannot be computed exactly, since this skill deliberately refuses to do that.

Download the skill