OpenClaw Dashboard: Everything You Can Do From the Web UI

The OpenClaw dashboard is your control plane. It's where you monitor active sessions, manage installed skills, connect nodes, check the Nerve/Kanban board, and configure your instance — all from a browser without touching the terminal.

It's available at http://localhost:3080 by default, or at whatever domain you've pointed at your instance (see the Docker setup guide for nginx/SSL configuration).

This is a practical walkthrough of what's actually there and what you can do with it.

Accessing the Dashboard

Point your browser at your OpenClaw instance:

• Local install: http://localhost:3080
• Docker/VPS: https://openclaw.yourdomain.com
• Mobile: Same URL, works in any mobile browser

On first load, you'll authenticate with your gateway token. This is the OPENCLAW_GATEWAY_TOKEN you set in your environment. Once authenticated, the session is stored in your browser — you stay logged in until you clear it or the token rotates.

If you're locked out, restart the gateway with a known token:

openclaw gateway restart

Or in Docker:

docker compose restart openclaw

Dashboard Overview

The main dashboard layout has a sidebar on the left and a content area on the right. The sidebar contains the primary navigation:

• Sessions — active and recent agent sessions
• Skills — installed skills and the ClawHub browser
• Nodes — connected devices and remote machines
• Nerve Board — Kanban task tracker
• Settings — API keys, channels, gateway config

The top bar shows gateway status (green = running), current model, and any active agent count.

Sessions Panel

The Sessions panel is where you watch your agents work.

Active Sessions

Each running session shows:

• Session ID and type (main, subagent, cron)
• Start time and duration
• Current status (thinking, executing, waiting, idle)
• The last message or action taken

Click any session to open the full log. You can read the complete conversation history, see every tool call the agent made, and inspect the inputs/outputs of each action.

Session Logs

Session logs are the most useful debugging tool in OpenClaw. When an agent does something unexpected, open its session log and scroll through:

• Every message it processed
• Every tool it called (exec, read, web_fetch, etc.)
• The exact input and output of each tool call
• Any errors or exceptions

This is how you catch a misbehaving agent fast. Look for: unexpected file writes, tool calls to wrong paths, error responses being silently swallowed.

Spawning Sessions

From the Sessions panel, you can manually spawn a new session:

• Select the model
• Choose session type (main, isolated subagent)
• Optionally set a working directory
• Type your first message to kick it off

This is useful for testing skill behavior in isolation or running a one-off task without going through your chat channel.

Killing Sessions

Any running session can be terminated from the panel. Click the session → "Terminate". This sends a kill signal to the agent process. For stuck agents (running but not responding), use "Force Kill" which sends SIGKILL.

Sessions terminate cleanly in most cases — the agent writes a final memory note before stopping. Force kills skip this step.

Skills Management

The Skills panel shows everything installed on your instance.

Installed Skills List

Each skill entry shows:

• Skill name and version
• Description (pulled from the skill's SKILL.md)
• Install date and source (ClawHub or local)
• Last used timestamp

Click any skill to read its full SKILL.md in the dashboard. This is the exact text your agent reads when deciding whether to use the skill — useful for debugging why a skill isn't triggering.

Installing from ClawHub

The dashboard includes a ClawHub browser. Search by name or category, click to install. No terminal required.

Under the hood, this runs clawhub install <skill-name> and triggers a skill reload. The skill is available to your agent immediately.

For skills that require configuration (API keys, file paths), the dashboard shows a setup checklist based on the skill's prerequisites section. Fill these out before using the skill — the agent will fail if required config is missing.

Updating Skills

The Skills panel shows which installed skills have updates available. Click "Update All" to pull latest versions from ClawHub, or update individually. Updates take effect without a gateway restart.

Local Skills

Skills you've built locally and placed in the skills directory appear here too, tagged "Local". They don't have update notifications (since they're not tracked by ClawHub), but you can reload them manually after editing.

To build your own skill, see the OpenClaw Skills guide.

Node Connections

Nodes are additional machines connected to your OpenClaw instance. The Nodes panel manages all of them.

What a Node Is

A node is any device running the OpenClaw node client — a phone, a second laptop, a homelab server, a remote VPS. Nodes connect to your gateway and extend what your agent can reach.

From the node connection, your agent can:

• Execute commands on the remote machine
• Read/write files on the remote filesystem
• Control the remote browser
• Access local services that aren't publicly exposed

Connecting a Node

Each new node gets a pairing code or QR code generated from the Nodes panel:

1. Click "Add Node"
2. Dashboard generates a pairing token (expires in 10 minutes)
3. On the device you're connecting: install the OpenClaw companion app or the node client
4. Enter the pairing code or scan the QR code
5. Connection establishes and the node appears in the panel

For Android/iOS companion apps, the QR scan flow handles the pairing automatically. For server nodes, you'll run:

openclaw node pair --gateway https://openclaw.yourdomain.com --token <pairing-token>

Node Status

Each connected node shows:

• Device name and OS
• Last seen timestamp
• Connection latency
• Available capabilities (browser, file system, shell)

Nodes go offline if the device goes to sleep or loses connection. They reconnect automatically when the device comes back online. You can manually ping a node to check its status or remove stale connections.

Nerve Board (Kanban)

The Nerve Board is the built-in task tracker. It's a Kanban board where your agent tracks work-in-progress, queues tasks, and logs completed work.

Board Columns

Default columns:

• Backlog — tasks queued but not started
• In Progress — active work
• Review — done but needs human review
• Done — completed

Your agent moves cards through these columns as it works. You can also create tasks manually from the dashboard and assign them.

How Agents Use the Board

When an agent picks up a multi-step task (writing 5 articles, deploying 3 services, etc.), it creates a card for the overall task and subcards for each step. As it completes steps, it updates card status.

This gives you a real-time view of what's happening without reading session logs. If a card has been in "In Progress" for 30+ minutes with no update, check the session log — something probably got stuck.

Task Approval Flow

Certain tasks require explicit approval before the agent proceeds. These appear in "Review" with an approval prompt. Click "Approve" to let the agent continue or "Reject" to stop it and leave a note.

The approval flow is triggered by tasks marked as requiring human sign-off in your AGENTS.md configuration — typically deploys to production, external communications, or anything touching billing.

You can also approve via API:

curl -X POST https://openclaw.yourdomain.com/api/kanban/tasks/<id>/approve \
  -H "Authorization: Bearer <token>"

Settings

The Settings panel handles instance configuration.

API Keys

Add or rotate API keys for:

• Anthropic (Claude models)
• OpenAI (GPT models, Codex)
• Other providers configured in your install

Keys are stored encrypted. The dashboard never shows full key values after saving — only the last 4 characters for identification.

To rotate a key: paste the new key over the old one, save. The change takes effect on the next session start (active sessions continue using the old key until they complete).

Channel Configuration

Connect communication channels your agent responds through:

Telegram: Enter your bot token and chat ID. Test the connection — the bot sends a verification message if configured correctly.

Discord: Enter bot token and default channel ID. Requires a Discord application with bot permissions.

Web UI: Always available — the dashboard itself is a channel.

Each channel can be set as a trusted channel (commands from here can control the agent) or informational-only (agent can read but won't take commands). See your SOUL.md for the security model.

Model Configuration

Set the default model for new sessions. Options depend on what API keys you've configured. Common choices:

• anthropic/claude-sonnet-4-6 — fast, capable, default for most work
• anthropic/claude-opus-4-7 — more capable, slower, costs more
• openai/gpt-4o — alternative if you prefer OpenAI

You can override the model per-session from the Sessions panel.

Cron Management

The Settings panel includes a cron manager. View all scheduled tasks, add new ones, and enable/disable without editing crontab manually.

Each cron entry shows:

• Schedule (cron expression)
• Task description
• Last run time and result
• Next run time

For a new cron task, you specify the schedule and the prompt you'd send to the agent. The dashboard handles spawning an isolated session at the right time.

Mobile Access

The dashboard works on mobile browsers — no dedicated app needed for the web UI. The responsive layout adjusts for smaller screens.

Mobile-specific considerations:

• Session logs are long — use the search/filter to find what you need instead of scrolling
• Nerve Board switches to a single-column list view on narrow screens
• Node QR pairing is easiest on mobile (the QR is right there on screen to scan with the companion app)

For native mobile control, the iOS and Android companion apps give you a dedicated UI. Pairing is handled via the Nodes panel as described above.

---

The dashboard is useful for monitoring, but most of your actual interaction with OpenClaw happens through channels (Telegram, Discord) where you send natural language requests. Think of the dashboard as the ops console — you check it when something needs attention, not as the primary interface.

For setting up the whole stack, see What Is OpenClaw. For skill management details, see OpenClaw Skills. For Docker deployment with nginx behind it, see OpenClaw Docker.

Want to see this running in production? Use the dashboard patterns above to monitor your own deployment.