Neurosymbolic AI for accountable agents

Build domain-specific harnesses for regulated verticals.

Turn SOPs and specs into agents you can audit.

DeepClause turns specs and SOPs into executable logic programs — deterministic rules for what must never go wrong, scoped LLM steps for the rest.

Get started with sop2harness SDK & CLI Docs

terminal sop2harness CLI

SOP → s2h create → harness → export → chat / MCP

What it is

Specs and SOPs in, auditable agents out.

Executable specs

Specs become programs with guaranteed control flow, typed outputs, and constraints — not prose an agent may ignore.

sop2harness

One CLI from SOP to a versioned harness: procedures and policies as executable Skills.

Local & secure

Runs well on local models: deterministic control flow, scoped LLM steps, and a portable sandbox.

How it works

From SOPs to a harness, to any MCP client.

sop2harness compiles your SOPs into a harness — procedures and policies as executable Skills. Drive those Skills directly from a chat UI, or export them over MCP to Claude and other agents.

flowchart LR
    SOPs[("📄 SOPs
Policies · procedures
and specs")]
    S2H{{"⚙️ sop2harness
Compile into a harness"}}
    Harness["🧩 Harness
Procedures and policies
as executable Skills"]
    Chat["💬 Chat UI
Direct link to the Harness"]
    Export["🔌 Executable Skills
Exported via MCP"]
    Clients(["🤝 MCP ↔ Claude / others"])

    SOPs --> S2H --> Harness
    Harness -->|direct| Chat
    Harness -->|export| Export
    Export --> Clients

    classDef source fill:#ffffff,stroke:#cac2b4,stroke-width:1.5px,color:#16181d;
    classDef build fill:#eef6f7,stroke:#0a7a8c,stroke-width:1.5px,color:#075463;
    classDef core fill:#0a7a8c,stroke:#075463,stroke-width:2px,color:#ffffff;
    classDef deliver fill:#ffffff,stroke:#0a7a8c,stroke-width:1.5px,color:#075463;
    classDef external fill:#111628,stroke:#111628,color:#e6f0ff;

    class SOPs source;
    class S2H build;
    class Harness core;
    class Chat,Export deliver;
    class Clients external;

sop2harness

Turn a 100-page SOP into a harness that follows it — verifiably.

s2h compiles an SOP into one auditable harness of executable Skills, versions it, and exports it as a self-hosted API, web chat, and MCP server. Authoring happens in a pi session; the runtime is deterministic DML.

Deterministic spine

Rules run in code

Amounts, thresholds, and deadlines are computed in DML — never judged by the model.

Agentic leaves

Models do scoped steps

Reading and drafting run as LLM steps with only the tools that phase allows.

Verified & explainable

Results are checked and traceable

A run records every rule, tool call, and model step, so the result can be re-checked and explained — not just taken on trust.

Nothing is accepted because the model said so: the policy is a program you can read, and every run leaves a trace you can audit.

Flowchart of a payer overpayment SOP: understand the request, confirm with the user, compute the disposition, take actions, verify seven post-conditions. — Presentation grade — the flow a reviewer reads first. Open full size

Specification-grade DeepClause diagram of the credit-balance policy, including declared read and write tools. — Specification grade — every phase and its allowed tools. Open full size

Read: make SOPs executable →

Built for regulated work

Audit-ready by construction.

When an agent moves money or touches regulated data, “the model said so” is not an answer. Encode each vertical's SOP as an auditable harness with deterministic rules, scoped tools, and a full trace.

Traceability

Every step is recorded; --trace writes a run record for review.

Policy as code

Policies live in version control and go through code review.

Least privilege

Tools are scoped per phase. Prohibited actions have no capability.

Data residency

Local or on-prem models; network egress off by default.

Deterministic controls

Monetary and eligibility logic produces the same result every run.

Visual audit

Generated diagrams show reviewers the policy and its limits.

Healthcare & RCM Insurance Financial services Public sector Legal operations

Decision models

DML can route a bounded call to a decision model instead of a general LLM — choose, rate, verify, or probability — and branch on the typed answer. Plug in Jev (TypeSafe System One) for calibrated probabilities, or run the same predicates on your own model.

Local & secure

Runs well on local models — better than instructions alone.

Deterministic DML carries the control flow, so a small local model only has to handle the scoped steps.

Secure

Secure code execution thanks to a sandboxed WebAssembly logic core.

Deterministic DML runs in a WASM logic core, reachable only through explicit host hooks.
Shell tools run in a portable AgentVM sandbox, with network off by default.
Static taint analysis flags untrusted data reaching prompts, tools, or memory.

Private

Because DML gives each run a deterministic control flow, the model only has to handle scoped steps — so smaller local models go further. Point DeepClause at Ollama, vLLM, LM Studio, or any OpenAI-compatible server, and your data stays on the machine.

Measured lift. On DeepPlanning travel planning, DeepClause raised a 35B local model from 22.2% to 42.9% composite and from 82.5% to 98.3% task delivery.