Agent host integrations

Plugins for local, auditable agent work.

The Scholialang plugin layer lets agent hosts write explicit Scholialang traces while keeping storage local. Codex, Claude Code, and Ollama-backed MCP hosts use the same stdio server, SQLite-backed DAGs, bounded recall tools, and full v0.6 validator.

Open plugin repo Codex setup Claude Code setup Ollama setup Local live view

What ships

One local server, host-native packages.

Codex plugin

Scholialang tools inside Codex.

Start DAGs, append typed atoms, search prior traces, compact session state, and import full Codex rollout exhaust without leaving the Codex workspace.

Claude Code plugin

Scholialang tools inside Claude Code.

Install from a Claude Code marketplace or load the plugin directory directly while developing. The bundled MCP server starts with the Claude Code session.

Ollama recipes

Local models through MCP-capable hosts.

Continue.dev, Cline, open-webui, and generic stdio MCP recipes launch the same Scholialang server for Ollama-backed model sessions.

Local MCP server

Stdio, SQLite, no hosted service.

The plugin launches a stdio MCP server and stores traces in a local SQLite database. Set SCHOLIALANG_HOME for project-local storage.

v0.6 validator

Full grammar checks in every host.

scholia_lint_snippet and scholia_lint_trace cover closed-set atoms, reference completeness, decisions, actions, hypotheses, retractions, operators, and location/edge shape.

Before you install

One repo, a marketplace per host.

dougfirlabs/scholialang-mcp is the marketplace root — both hosts add it straight from GitHub, no clone needed. Codex reads .agents/plugins/marketplace.json and installs the plugins/codex/scholialang package; Claude Code reads .claude-plugin/marketplace.json and installs plugins/claude-code/scholialang. Each package bundles its manifest, skill, MCP config, and server scripts.

Two ways in. The host plugins below install from that GitHub marketplace — the path for Codex and Claude Code. If you only need the MCP/LSP server as a Python package, install it directly from PyPI instead: pip install scholialang-mcp.

Requires git, python3, and the host CLI you are installing into.
Set SCHOLIALANG_HOME before launching the host when you want a project-local SQLite store.
Open a new Codex thread or run Claude Code's plugin reload after changing plugin files.

Direct PyPI install · MCP/LSP package

pip install scholialang-mcp

Repository layout

scholialang-mcp/
  .agents/plugins/marketplace.json
  .claude-plugin/marketplace.json
  plugins/codex/scholialang/
    .codex-plugin/plugin.json
    .mcp.json
    skills/  scripts/scholialang_mcp_server.py
  plugins/claude-code/scholialang/
    .claude-plugin/plugin.json
    .mcp.json
    skills/  scripts/scholialang_mcp_server.py
    scripts/scholialang_webview_server.py
  plugins/ollama/scholialang/
    recipes/  scripts/scholialang_mcp_server.py

Codex setup

Install as a Codex plugin.

The Codex plugin install loads the Scholialang skill, icon, metadata, and bundled MCP configuration from plugins/codex/scholialang/.mcp.json. Start a new thread after installation so Codex can initialize the plugin-provided scholia_* tools.

Add dougfirlabs/scholialang-mcp as a marketplace source — Codex fetches it from GitHub.
Install scholialang@scholialang-mcp from that marketplace.
Launch Codex from the project you want traced, with SCHOLIALANG_HOME set if you want repository-local storage.
Open a new thread and confirm the scholia_* tools are available before relying on live trace emission.

Install from GitHub

codex plugin marketplace add dougfirlabs/scholialang-mcp
codex plugin add scholialang@scholialang-mcp
codex plugin list

Launch in a traced project

cd /path/to/project
export SCHOLIALANG_HOME="$PWD/.scholialang"
codex

Direct MCP fallback

codex mcp add scholialang \
  --env SCHOLIALANG_HOME=/path/to/project/.scholialang \
  -- python3 /absolute/path/to/scholialang-mcp/plugins/codex/scholialang/scripts/scholialang_mcp_server.py

Claude Code setup

Install as a Claude Code plugin.

The Claude package uses .claude-plugin/plugin.json and a plugin-root .mcp.json. When the plugin is enabled, Claude Code starts the bundled stdio MCP server automatically and lists it in /mcp with the other connected servers.

Add dougfirlabs/scholialang-mcp as a marketplace source — Claude Code fetches it from GitHub.
Install scholialang@scholialang-mcp; defaults to user scope, or pass --scope project / --scope local.
Launch Claude Code from the project you want traced, using the same SCHOLIALANG_HOME convention as Codex.
Run /reload-plugins in an existing session, then /mcp to confirm scholialang is connected.

Install from GitHub

claude plugin marketplace add dougfirlabs/scholialang-mcp
claude plugin install scholialang@scholialang-mcp

Launch and verify

cd /path/to/project
export SCHOLIALANG_HOME="$PWD/.scholialang"
claude

/reload-plugins
/mcp

Development shortcut

claude --plugin-dir /absolute/path/to/scholialang-mcp/plugins/claude-code/scholialang

Ollama setup

Use the stdio server from any MCP-capable local-model host.

Ollama serves the model. Continue.dev, Cline, open-webui, or another MCP-capable harness launches Scholialang as a local stdio server. Point that harness at plugins/ollama/scholialang/scripts/scholialang_mcp_server.py and use the same SCHOLIALANG_HOME path if you want its traces to appear beside Codex and Claude Code traces.

Clone dougfirlabs/scholialang-mcp and make sure Ollama is running.
Open your local-model harness's MCP server configuration.
Add a stdio MCP server named scholialang that runs the bundled Python script.
Restart the harness and ask it to start a Scholialang trace for the current project.

Generic MCP config

{
  "mcpServers": {
    "scholialang": {
      "command": "python3",
      "args": [
        "/absolute/path/to/scholialang-mcp/plugins/ollama/scholialang/scripts/scholialang_mcp_server.py"
      ],
      "env": {
        "SCHOLIALANG_HOME": "/path/to/project/.scholialang"
      }
    }
  }
}

Smoke prompt

Start a Scholialang trace for this project.

Project-local traces

Store working memory with the project.

For active development, point Scholialang at a repository-local storage root and keep the generated database and exports out of Git. Point each host at the same directory when you want cross-host trace visibility. The live webview reads from this same directory, so start Codex, Claude Code, the local-model harness, and the webview with the same SCHOLIALANG_HOME value.

cd /path/to/project
export SCHOLIALANG_HOME="$PWD/.scholialang"
# then launch Codex, Claude Code, or your MCP-capable local-model host

.scholialang/*.sqlite3
.scholialang/*.sqlite3-*
.scholialang/exports/

Default behavior

Quiet until review is requested.

Recall bounded context.

Use summaries, frontier reads, neighborhoods, and search before pulling a large trace into a chat session.

Append meaningful atoms.

Record observations, evidence, findings, decisions, actions, contradictions, retractions, and summaries at durable work boundaries.

Validate before sharing.

Run full v0.6 lint checks for closed-set atoms, references, decisions, actions, hypotheses, retractions, operators, Concluding closure, canonical_id well-formedness, warning rules, and location/edge shape.

Import full exhaust explicitly.

Use Codex exhaust imports for audit, token usage, provenance, or debugging when a Codex rollout is available. They are intentionally complete and verbose.

Local live view

Watch the SQLite DAG update in a local browser.

The webview is a separate localhost server. It does not replace the MCP server and it does not send traces to Cloudflare. Agent hosts write atoms through the stdio MCP tools, SQLite stores the DAG, and the browser reads snapshots plus Server-Sent Events from 127.0.0.1.

<Trace id="dag_..." title="Agent trace review">
  <Finding id="Finding_0001">
    Live review should stay local to the SQLite DAG.
  </Finding>
  <Edge from="Finding_0001" to="Observation_0001" relation="derived_from"/>
</Trace>

Start the webview.

Run it from a checkout of scholialang-mcp. Pass the project path you want the UI to filter by.

Open the local URL.

Use Chrome, the Codex in-app browser, or any browser that can reach http://127.0.0.1:8765/.

Emit atoms from a host.

Codex, Claude Code, or an MCP-capable local-model harness writes to SQLite through scholia_dag_start and scholia_dag_add_atom.

Review the graph.

The browser shows recent DAGs, atom cards, edges, AST connections, and streaming status without adding trace text to the agent chat.

Run it locally

Use the same storage root as the agent host.

If the webview opens but no atoms appear, the browser is usually reading a different SQLite store than the host is writing. Export SCHOLIALANG_HOME in the shell that starts the webview, and launch the agent host with that same value.

--project-path filters the recent DAG list and labels snapshots for one repository.
--open-chrome opens the URL in Google Chrome; omit it when you want to use the Codex in-app browser.
--port changes the default 8765 port if something else is already listening.

Start local webview

cd /absolute/path/to/scholialang-mcp
export SCHOLIALANG_HOME=/path/to/project/.scholialang
python3 plugins/claude-code/scholialang/scripts/scholialang_webview_server.py \
  --project-path /path/to/project \
  --open-chrome

Browser URL

http://127.0.0.1:8765/

/ Interactive live UI.

/api/dags Recent DAG metadata for the selected project.

/api/snapshot?dag_id=... Current atoms, links, and graph summary for one DAG.

/events?dag_id=... Server-Sent Events stream used for live updates.

No updates? Check that the host exposes scholia_* tools, the host and webview share SCHOLIALANG_HOME, the selected DAG belongs to the same project_path, and the plugin was reloaded or the host session restarted after installation.