arthai-marketplace

Configuration

Auto-configuration

The fastest way to configure is:

/calibrate

This scans your codebase and sets up agents, skills, and hooks to match your project’s patterns. It’s safe to run multiple times.

Manual configuration

Project-specific agents

Add custom agents as .md files in your project’s .claude/agents/ directory. These run alongside the plugin agents.

Project-specific skills

Add custom skills as directories in .claude/skills/. Each skill needs a SKILL.md file with frontmatter.

Overriding plugin defaults

Project-local files take precedence over plugin-provided ones of the same name:

Create .claude/agents/<name>.md (or .claude/skills/<name>/SKILL.md) in your project
Give it the same name: as the plugin agent/skill you want to replace

Your override is a regular project file — future plugin updates never touch it.

Bundle selection guide

You need…	Install
Full dev workflow (planning, implementing, QA, PRs)	`forge`
Bug fixing only	`scalpel`
Project setup and onboarding	`spark`
SRE and incident response	`sentinel`
Deep QA testing	`prism`
Safety guardrails + compliance extensions	`shield`
Design workflows	`canvas`
Product management	`compass`
Consulting toolkit	`counsel`
Autonomous mode	`cruise` (requires forge + scalpel + sentinel)
Everything	`prime`

Multiple bundles

You can install multiple bundles. They compose without conflicts:

/plugin install forge@arthai
/plugin install sentinel@arthai
/plugin install prism@arthai

Observability (OTEL)

The sentinel bundle includes the otel-telemetry hook and /otel-setup skill for tracing every Claude Code session.

Setup

/otel-setup

The skill prompts for your preferred setup. Pick “Local” — it runs everything on your machine.

Prerequisite: Docker Desktop installed and running.

The skill pulls arthai/intelligence from Docker Hub, starts the engine + dashboard + Postgres, and configures everything automatically.

The skill writes these env vars to .claude/settings.local.json (project-local, git-ignored) by default, or to your shell profile if you pick the global scope:

Variable	Required?	Purpose
`CLAUDE_CODE_ENABLE_TELEMETRY=1`	Required for cost data	Enables Claude Code’s native OTEL emitter — only path that produces cost USD, input/output/cache tokens, and model. Without this, dashboard cost columns stay empty.
`OTEL_EXPORTER_OTLP_ENDPOINT`	Required	Where spans and metrics are sent (e.g., `http://localhost:4319` for the local Docker collector).
`OTEL_EXPORTER_OTLP_PROTOCOL=http/json`	Required	Native OTEL defaults to gRPC/protobuf, which most simple HTTP collectors reject silently. http/json is the format Arth Intelligence and most plain HTTP collectors accept.
`OTEL_EXPORTER_OTLP_HEADERS`	Optional	Auth headers (e.g., `Authorization=Bearer <key>`) — needed for cloud-hosted collectors only.
`OTEL_METRICS_EXPORTER=otlp`	Required	Route native metrics (cost / tokens) to OTLP.
`OTEL_LOGS_EXPORTER=otlp`	Required	Route native logs to OTLP.
`OTEL_TRACES_EXPORTER=otlp`	Required	Route native traces to OTLP.

What gets traced

The hook captures 22 Claude Code event types:

Session lifecycle: start, end, stop failure
User prompts: with skill detection (freeform vs /skill-name)
Agent lifecycle: start/stop with cost tier (opus-60x, sonnet-10x, haiku-1x) and duration
Tool calls: pre/post with input summary, output summary, and wall-clock duration
Tasks: created/completed with subject
Errors: tool failures, permission denials with error messages
Context: compaction events, instructions loaded, cwd changes
Environment: worktree create/remove, notifications, teammate idle

Critical spans (session.end, agent.stop) are sent synchronously with a 1s timeout for reliable delivery. All other spans are fire-and-forget (<10ms overhead).

Auto-trigger

If the hook is installed but OTEL is not configured, it automatically prompts you to run /otel-setup on your next session start. This only fires once — after setup, a marker file (~/.arthai/otel-configured) prevents re-prompting.

Disabling

export OTEL_DISABLED=true

“Explain this session” — optional LLM key

The Intelligence dashboard’s grounded “Explain this session” summary calls an LLM directly (NOT your Claude Code subscription — separate, API-billed). It’s optional: with no key the dashboard shows a “needs an LLM key” prompt where the summary would go (it doesn’t silently vanish).

Where you configure it (it’s NOT experimental): you can enable Explain in either setup command — you do not need to turn on the experimental Cloud Orchestrator:

With the toolkit: /otel-setup offers it at the end, or run /cloud-setup (Step 1).
Without the toolkit (CLI): arth otel-setup offers it at the end, or run arth cloud-setup. (First install the Arth CLI — gated by your GitHub repo access, no public package.)

Either way your choice lands in ~/.arthai/.env and survives image updates (pulls and Watchtower never remove it). Use any one provider — a small / flash-tier model is recommended (it only summarizes facts):

Provider	Env var	Recommended (small) model
Anthropic	`ANTHROPIC_API_KEY`	`claude-haiku-4-5`
OpenAI	`OPENAI_API_KEY` (+ `OPENAI_BASE_URL` for gateways)	`gpt-4o-mini`
Gemini	`GEMINI_API_KEY`	`gemini-2.0-flash`
Ollama (local, free)	`OLLAMA_HOST`	`llama3.1` (8B)
LM Studio (local, free)	`LMSTUDIO_HOST`	auto-detected loaded model (e.g. qwen)
Bedrock (API key)	`AWS_BEARER_TOKEN_BEDROCK` (+ `AWS_REGION`)	`anthropic.claude-3-5-haiku-...`

Override the model with ARTH_EXPLAIN_MODEL and force a provider with ARTH_EXPLAIN_PROVIDER (accepts lmstudio/ollama). Cost: ~$0.001–0.002 per session on the cloud models (cached per session) → a few dollars/month even at heavy use, or $0 with local Ollama / LM Studio. Don’t use a frontier model here — flash/mini tier is the right size.

Keys at a glance — which do you actually need?

Most of the dashboard needs no key. What you need depends on the two opt-in AI features — and a fully local, zero-key setup is a first-class path:

What you want	Key / credential needed	How to get it
Telemetry only (sessions, cost, DAG) — `/otel-setup`	None	—
Explain on a local model (Ollama / LM Studio + qwen)	None ($0, nothing leaves your machine)	Install Ollama or LM Studio, load a model, start its server — see below
Explain on a cloud model	that one provider’s API key (Anthropic / OpenAI / Gemini / Bedrock)	from that provider
Cloud Orchestrator (experimental, Claude-only) — `/cloud-setup`	`ANTHROPIC_API_KEY` + a GitHub fine-grained token + your Arth license	Cloud Orchestrator → Prerequisites

The local zero-key path (Explain via Ollama / LM Studio, orchestrator off) is the cheapest and most private setup — no provider account, no API bill. The only access you need is the same the toolkit already required: your Arth license (getting started) and repo access to ArthTech-AI/arthai-marketplace. Set it up in /otel-setup (inline) or /cloud-setup, then decline the orchestrator when asked.

Local models step-by-step (Ollama or LM Studio — free)

Both run a local server that the dashboard reaches over the OpenAI-compatible API. The dashboard runs inside Docker, so you must point it at host.docker.internal, not localhost.

LM Studio + qwen (or any model):

In LM Studio, download/load the model you want (e.g. a Qwen3 model).
Open the Developer / Local Server tab → Start Server → enable “Serve on Local Network” (so the Docker container can reach it). Default port is 1234.
Set the env var (or just pick “LM Studio” in /otel-setup / /cloud-setup):
```
echo 'LMSTUDIO_HOST=http://host.docker.internal:1234' >> ~/.arthai/.env
```
The loaded model is auto-detected via /v1/models — you don’t need to type its id. To pin a specific one: echo 'ARTH_EXPLAIN_MODEL=<id from /v1/models>' >> ~/.arthai/.env.
Recreate the dashboard:
```
docker compose -f ~/.arthai/docker-compose.yml up -d
```
(Add -f ~/.arthai/docker-compose.override.yml too if you’ve enabled the orchestrator.)

Ollama:

ollama pull llama3.1 (or your model).
echo 'OLLAMA_HOST=http://host.docker.internal:11434' >> ~/.arthai/.env
Recreate the dashboard (same command as above).

Linux note: if host.docker.internal doesn’t resolve, the container needs --add-host=host.docker.internal:host-gateway (Docker Desktop on macOS/Windows adds it automatically), or use the host’s LAN IP.

Note — the Cloud Orchestrator is Claude-only (for now). Explain can use any provider above, but the experimental orchestrator’s sandbox runs Claude and needs its own ANTHROPIC_API_KEY. So if you set Explain to a non-Claude provider and turn on the orchestrator, you’ll be asked for a Claude key as well — both are kept in ~/.arthai/.env.

Updating plugins

Enable auto-updates once: run /plugin, open the Marketplaces tab, select arthai, choose Enable auto-update. Manual update:

/plugin marketplace update arthai
/plugin uninstall <your-bundle>@arthai   # then reinstall, e.g. prime
/plugin install <your-bundle>@arthai
/reload-plugins

After an update that adds a brand-new command, fully quit and reopen Claude Code. /reload-plugins refreshes existing commands but a running session won’t surface a newly added one (e.g. /cloud-setup) until a full restart rebuilds the command set. If an update still doesn’t take, use the full reset flow in the FAQ.

Context budget

The toolkit injects guidance into your session — a routing table that picks the right agent/skill for each request, plus a one-line session-start status. Unlike toolkits that load every persona on every message, this one is deliberately lean: the full routing table is injected once per session, then each later turn gets only a compact reminder.

Measured on a reference session:

Injection	Tokens	Frequency
Session-start status	~30	once
Full routing table	~1,700	once (first message)
Compact reminder	~30	each turn after
Startup total	~1,750	once
20-turn session	~2,300	—

These numbers are not hand-typed — run scripts/token-budget.sh (or --json) in the source repo for the live figure, which the script re-measures by actually running the hooks. For comparison, framework context bloat is the most-cited complaint about competing toolkits; keeping steady-state cost near ~30 tokens/turn is a deliberate design choice.