Integrations

Set Seligo up as the model provider inside the tools you already use. Every step below runs against the live Seligo platform — the same catalogue, provenance, budgets and access rules as the API and the chat window. There is no stub in this path.

Allow about ten minutes per tool. Follow the sections in order; each one ends with something you can see, so a failure is obvious before you move on.

Before you start

1. Get a key

1. Sign up or sign in at console.seligo.cloud. Signup creates a Seligo org — the isolation boundary for billing, keys and usage.
2. Open Billing and add funds. Usage is metered in EUR, and requests fail closed when the balance runs out.
3. Open Keys and create a key. It looks like rk-…. Copy it once, into the tool you are configuring.

If you need a colleague to demo on their own machine, invite them as a member of the org and have them create their own key, so usage and budgets stay attributable. See Getting started for the full org setup.

2. Demo run sheet

Work top to bottom. Each line is one visible result; if a line does not hold, stop and use the troubleshooting table before continuing.

1. Key — GET /v1/models returns your catalogue.
2. VS Code — the model picker lists a Seligo group, and @seligo answers with a provenance footer.
3. OpenCode — opencode models seligo lists seligo/… entries, and one turn streams an answer.
4. OpenClaw — openclaw models list --refresh --provider seligo lists the catalogue, and one agent turn completes.
5. Microsoft 365 (optional) — the pane lists models after sign-in and completes a streamed turn.

The catalogue size depends on the org, the key and the live supplier set; it changes between checks. Never quote a fixed model count in a demo.

3. Visual Studio Code

The extension makes Seligo a model provider inside the editor’s own chat, so you keep the agent you already use. The status bar carries the zone chip and, beside it, a running session spend counter (€0.0015 · 1.5k) that updates as each turn completes — the glanceable number, while the turn ledger stays the audit view.

Download the current build:

Download the Seligo extension  seligo-0.5.2.vsix · 53 KB · Apache-2.0

Install it from the command line:

code --install-extension seligo-0.5.2.vsix

Or in the editor: Extensions → … → Install from VSIX…. VSCodium, Cursor and Windsurf use the same command with their own CLI name (codium, cursor, windsurf).

Then store your key once, from the Command Palette:

Seligo: Set API key

The key goes into the editor’s secret store — never into settings.json. If you reinstall a newer build, install it over the top (--force): uninstalling first deletes the secret store and your key with it.

Pick a model

Open the chat model picker. Every Seligo model carries its provenance in the name, with price and context on the row:

🟦 EU · standard · deepseek-v3        €0.24 / €0.90 per M · 163,840 ctx

Ask with provenance on the answer

Type @seligo in the chat to talk to Seligo directly. Each answer ends with the model that produced it, where it ran, the retention posture, the price and the response time:

> deepseek-v3 · EU · ZDR-confirmed · €0.24 / €0.90 per M · 1.4 s

This is the difference between the two ways of using the extension: in ordinary chat the provenance is on the model you selected; with @seligo it is on each answer, so a conversation that switches models stays readable.

Audit what happened

Run Seligo: Show provenance to open the panel. It lists every model your key can use, and a turn ledger of the requests this workspace has sent: model, zone, retention, tokens, cost, latency and outcome. Seligo: Export turn ledger copies it as markdown.

The ledger holds metadata only — no prompts and no responses — so it can be shared without carrying conversation content. The status bar shows the zone chip and a running session spend counter, which updates as each turn completes.

Requirements and known limits

• VS Code 1.104 or newer, on the stable API.
• Agent mode lists only models whose catalogue row declares tool calling. The router now publishes that from the supplier’s own metadata, so leave seligo.assumeToolCalling at its default (false): it is an assertion, not a measurement. Plain chat and @seligo work regardless.
• If a model shows a conservative input budget marked (fallback), the catalogue did not publish a context window for it. Set seligo.capabilityOverrides only when you know the real value.

4. OpenCode

Install Seligo for OpenCode with one command, the same way you install OpenCode itself — a curl | bash installer:

curl -fsSL https://docs.seligo.cloud/downloads/seligo-opencode-install.sh | bash

The installer checks Node.js and OpenCode, downloads and verifies the first-party Seligo plugin (SHA-256), registers the seligo provider in ~/.config/opencode/opencode.json (baseURL + your live catalogue, pinned — the key is never written to config), stores your key once in OpenCode’s auth store (~/.local/share/opencode/auth.json, chmod 600), and verifies the wiring. It backs up any existing config first. Run it once; opencode started from anywhere then lists Seligo.

You will be prompted to paste your rk- key, or pass it on the command line:

curl -fsSL https://docs.seligo.cloud/downloads/seligo-opencode-install.sh | bash -s -- --key "rk-…"

Options: --no-store-key (use SELIGO_API_KEY from the environment only), --no-modify-config (plugin only), --uninstall (remove everything, keeping your other providers), and --yes. The key is read from SELIGO_API_KEY (env) first, then the auth store.

Verify

List the live catalogue — the models are whatever your key may use:

opencode models seligo

The catalogue lists seligo/<model-id> entries. In the TUI, a provenance toast appears when a Seligo model answers, using the plain-language register from the catalogue. A model your organisation denies is absent, not greyed. Only chat-capable models are listed; embedding and audio rows are filtered out so the picker never offers something that cannot respond.

On OpenCode 1.18 the provider is registered by the config; the plugin file is not loaded from the plugins directory in that version (its presence there breaks discovery), so the installer keeps it as a verified reference copy. Newer OpenCode versions and the published npm package use the plugin for live discovery and provenance directly.

5. OpenClaw

OpenClaw keeps the agent loop; Seligo supplies the governed model plane. The plugin is version-pinned to the OpenClaw plugin API, so install OpenClaw 2026.9.8 for this demo:

npm install -g openclaw@2026.9.8
openclaw --version

Path A — from the Seligo repository

Use this if you have access to the private Gitea repository. The launcher builds and packs the workspace plugin, then installs that artifact into an isolated state directory:

cd seligo
pnpm install
export SELIGO_API_KEY="rk-…"
integrations/openclaw/run.sh install         # once: install + enable the provider
integrations/openclaw/run.sh models          # the live catalogue
integrations/openclaw/run.sh ask "hello"     # one agent turn
integrations/openclaw/run.sh dashboard       # Control UI

The launcher keeps its own state under integrations/openclaw/state, so your personal OpenClaw profile is untouched.

Path B — from the registry

Use this once the package is published. Check first:

npm view @seligo/openclaw-provider version

Not published as of 2026-10-21 — this command returns 404 today, and there is no ClawHub listing. Use Path A or Path C.

openclaw plugins install @seligo/openclaw-provider
openclaw plugins enable seligo
openclaw gateway restart
openclaw models list --refresh --provider seligo

Path C — from the hosted download (fallback)

Use this with no repository access and no registry package. Install the archive, enable the plugin, and store the key in OpenClaw’s credential store so the agent loop can resolve seligo/… model references:

openclaw plugins install ./seligo-openclaw-provider-0.1.0.tgz --force --accept-capabilities
openclaw plugins enable seligo

printf '%s' "rk-…" | openclaw models auth paste-api-key --provider seligo
openclaw models list --refresh --provider seligo

Download: seligo-openclaw-provider-0.1.0.tgz · 8 KB

OpenClaw warns that a local archive is outside ClawHub review — that is expected for a first-party build installed from this page.

What you should see

openclaw models list --refresh --provider seligo prints the catalogue with context windows. openclaw agent --model seligo/… -m "hello" completes one turn; openclaw dashboard opens the Control UI. If the gateway is not running, start it with openclaw gateway run.

6. Microsoft 365

The add-in is served from m365.seligo.cloud and signs in with your Seligo account — the same session as the console and chat, so no API key is stored in the browser. This needs a Microsoft 365 tenant; it does not work with a personal account that cannot sideload add-ins.

Download the manifest for your host:

Sideload for yourself

• Word or Excel — Home → Add-ins → More Add-ins → My Add-ins → Upload My Add-in, then choose manifest.xml.
• Outlook — Get Add-ins → My add-ins → Add a custom add-in → Add from file, then choose manifest.outlook.xml.
• On the web — Insert → Add-ins → Upload My Add-in.

Then open Home → Seligo → Open Seligo. Sign in with your Seligo account (email, password, TOTP). The pane lists the catalogue; the Context control switches between the selection and the whole document, and Insert (Word) or Apply to sheet (Excel) writes the answer back.

Working in the pane

• Follow-ups keep their thread. The pane keeps the conversation, so a second question can refer back to the first. Only what you typed is sent as history — the document is read fresh for each message, so a long conversation never resends a stale copy of it.
• Start over with New in the pane header. It clears the conversation and starts a fresh question. It appears once there is something to clear, and is disabled while an answer is still streaming.
• Copy or Insert a specific answer. Both actions sit on the answer itself, so an earlier reply stays usable after you have asked something else. Insert writes plain text (no Markdown markers) into Word.
• Nothing is stored. The conversation lives in the pane for the session only; closing the pane clears it, and no document or mail content is written to disk or logged.

Deploy to a tenant

For everyone in an organisation, upload the same manifest through the Microsoft 365 Admin Center → Settings → Integrated apps → Upload custom apps. Tenant deployment is an administrator action; the pane itself is unchanged.

7. Verify the live path

From a Seligo checkout, one command checks the key, the catalogue, the provenance block and a real streamed turn:

cd integrations
make live-check          # key, catalogue, provenance block, real streamed turn
make provenance-matrix   # which provenance cells the live catalogue evidences

live-check uses real inference with a bounded token budget. It exits with distinct codes, so a failure names its cause:

Without a checkout, the equivalent first check is one request:

curl -s "https://api.seligo.cloud/v1/models" \
  -H "authorization: Bearer rk-…"

8. What every integration shares

• Live model discovery from GET /v1/models — no hand-maintained list.
• Provenance from Seligo’s server-derived display block: the zone glyph and token, in the plain-language register on business surfaces. A model with no provenance reads UNKNOWN, never a default zone.
• Policy honesty — the list is exactly what your key may use. A model your organisation denies is absent, not greyed.
• One wallet — spend is metered and budgeted through the same router as the API and the chat window.
• Session spend — every turn is attributed to a session, and the cost of that turn comes back in the standard usage object (usage.cost, in EUR). Hosts that show a session cost therefore have a number to show without any custom integration, and the console session API is the authoritative rollup.
• Same model menu — the integrations present the same names, capabilities and EUR prices as the Seligo chat picker.

9. Session spend

“Session” is Seligo’s unit of attribution: a conversation in the chat window, an agent run in OpenCode or OpenClaw, or simply a key’s traffic within a 30-minute idle window. You never have to declare one — the router mints a sticky session id per API key — but a host that manages its own conversations should send its own id as session_id so the numbers line up with what the user sees.

• Per turn: usage.cost and usage.currency (EUR) in the response, plus seligo.cost_eur. Omitted, never zeroed, for endpoints and BYOK keys that Seligo does not price.
• Attribution: X-Seligo-Session-Id on every response; the VS Code extension records it in its turn ledger so a local total can be reconciled against the bill.
• Authoritative: GET /api/usage/sessions and /api/usage/sessions/{id} in the console — per-session tokens and spend, with a live reading beside the ledger. See the API reference.
• OpenCode specifically: the Seligo provider publishes each model’s EUR input/output price from the catalogue, which is what OpenCode uses to compute the session cost it displays. A hand-written baseURL (without the plugin) has no price metadata, so its cost view stays empty even though the turns are billed.

10. Troubleshooting

11. Downloads

Verify a download before installing it:

shasum -a 256 seligo-opencode-install.sh
# 98042531a1bffa1d19e0daaa64fe7de5753f9d51c773c8c0fbe3345874e5bfc