DeepClause runtime, tools, and language docs.

What DeepClause ships today

DeepClause separates orchestration, execution, and guidance into distinct surfaces. The conductor owns the conversation, compiled skills do the work, recipes provide reusable workflow guidance, and the runtime stays inspectable through local files, execution logs, and editable prompt assets.

Feature surface

• deepclause init seeds .deepclause/config.json, local tool folders, docs, system overrides, recipes, and default skills.
• .deepclause/system/TASK_PROMPT.md now controls the task and prompt harness used during execution, not just the packaged default.
• .deepclause/system/DML_COMPILER_PROMPT.md and .deepclause/system/CONDUCTOR_PROMPT.md let you tune compile-time and conductor behavior locally.
• The skill creator can generate helper assets under .deepclause/tools/lib/<skill-or-tool-name>/, including per-skill .venv environments when Python helpers are needed.
• Runtime shell execution can stay on the host or move into AgentVM; host isolation backends include clean-room, bwrap, and sandbox-exec when supported.
• DeepClause can use built-in runtime tools and MCP-exposed tools. deepclause list-tools shows the resolved set.
• Session and loop compaction are configurable with ordinary DML compactors bound to runtime hook points.
• Recipes live in .deepclause/system/recipes/ as searchable workflow guidance instead of executable worker code.
• The conductor can answer directly, call local skills, consult recipes, create new skills, run shell tools, and delegate to research-oriented workers.

Workspace layout

.deepclause/
  config.json
  docs/
    TUI.md
  sessions/
    <session-id>/
  system/
    CONDUCTOR_PROMPT.md
    DML_COMPILER_PROMPT.md
    TASK_PROMPT.md
    conductor.dml
    skill-creator.dml
    recipes/
  tools/
    my-skill.dml
    lib/
      my-skill/
        .venv/
        helper.py

The fullscreen conductor interface

Running deepclause with no subcommand launches the fullscreen TUI. The left pane shows sessions, the center pane holds the conversation, and the right side shows execution activity plus summarized context.

What the conductor does

• Loads the active session from .deepclause/sessions/<session-id>/.
• Builds a grounded system prompt from the conductor prompt, recipe library, session history, memory files, and skill catalog.
• Routes the turn to direct reasoning, an existing skill, a recipe-guided approach, or the skill creator.
• Streams child-skill activity into the execution pane and persists messages, usage, and execution logs back to disk.

Command bar inputs

Why the TUI matters

• It keeps routing decisions in one place: the conductor, not a pile of disconnected prompts.
• It exposes execution logs and context summaries instead of hiding the runtime behind chat output alone.
• It works with the same session files and system assets as headless usage, so debugging a TUI turn and a CLI turn stays comparable.
• It is designed for local repo work: memory files, transcript files, recipes, and tools are all read from the workspace.

Headless runs, compiled skills, and embeddable execution

The CLI covers install, init, compile, run, tool introspection, model slot management, and headless conductor turns. The SDK exposes the same execution engine directly to TypeScript code.

Quick start

npm install -g deepclause-sdk
export OPENAI_API_KEY="sk-..."
deepclause init --model openai:gpt-4o
deepclause

CLI reference

Configuration and runtime knobs

• providers configures OpenAI, Anthropic, Google, OpenRouter, or custom OpenAI-compatible endpoints.
• Three model slots separate conductor routing (gateway), worker execution (run), and compilation or skill creation (compile).
• shell.wrapper chooses the host isolation backend and shell.strictIsolation requests a stricter host mode.
• agentvm.network controls outbound network access when shell commands run with --sandbox.
• mcp.servers registers external tool providers that become visible in deepclause list-tools.
• compaction.bindings attaches DML compactors to hooks such as before_user_message and before_model_call.

SDK entry points

import { createDeepClause } from 'deepclause-sdk';

const dc = await createDeepClause({
  model: 'gpt-4o',
  apiKey: process.env.OPENAI_API_KEY,
  streaming: true,
});

for await (const event of dc.runDML(code, {
  args: ['report.md'],
  params: { max_results: 5, mode: 'brief' },
  workspacePath: process.cwd(),
  initialMessages: [
    { role: 'user', content: 'Use the repo conventions in memory.' },
  ],
})) {
  console.log(event.type, event.content ?? '');
}

await dc.dispose();

SDK event stream

Use the docs in two modes

The docs landing page is now paired with a dedicated examples page and a type-shaped SDK API reference. Use the examples page when you want runnable commands and the API page when you want exact option and event surfaces.

The language surface behind compiled skills

DML is a Prolog-flavored language for agent orchestration. It mixes normal logic programming with LLM calls, runtime tools, backtracking, recursion, and scoped tool exposure. The reference page below tracks the current runtime, including the modern task harness and the actual built-in task-loop tools.

tool(search(Query, Results), "Search the web for information") :-
    exec(web_search(query: Query), Results).

agent_main(Topic) :-
    system("You are a careful researcher."),
    task("Research {Topic} and store a concise summary.", Summary),
    prompt("Critique this summary: {Summary}", Critique),
    answer(Critique).