Reasoning as Code

The future isn’t bigger prompts — it’s governed reasoning

Let your AI understand the why, what, how, and who behind your data—with explainable answers. Get up to 10× lower token spend compared with dumping millions of warehouse rows into every prompt.

Start building SDK reference MCP setup

agent-session.log

RAG, Without AnythingGraph

# User asks the agent
> Who owns the account for Alex Rivera
and how much is the deal?

# Context stuffed into every prompt
Warehouse dump (2.1M rows) .......... 1,184,000 tok
RAG top-50 document chunks ..........   58,400 tok
Schema + table samples ..............    4,600 tok
────────────────────────────────────────
Prompt context total ................ 1,247,000 tok

# Agent reply — no access control
Dana Lee owns the account.
The deal is $2.4M
(read from finance pipeline — no access control!)

✗ Deal amount exposed — no graph scope
✗ Agent queried tables outside user scope
✗ AI Hallucination

With AnythingGraph

# Same question — governed MCP + proof
> Who owns the account for Alex Rivera
and how much is the deal?

# Scoped playbook capsule only
listRelationships(crm-access) .......   2,100 tok
sparqlQuery(data capsule) ...........   4,800 tok
Proof bundle (3 source records) .....   2,500 tok
────────────────────────────────────────
Prompt context total ................   9,400 tok

# Answer with proof (scoped to this user)
Source: Contact · Alex Rivera
  linked account → Northwind Traders
  account owner → Dana Lee
Deal amount: withheld — outside your access

✓ Every claim links to a source record
✓ Policy enforced before reply

132× fewer tokens - Explainable - No hallucination

Problems we solve

RAG and agents fail in production - we fix it

Developers hit the same walls — opaque answers, hallucinations, and chunk RAG that cannot traverse relationships.

No black-box answers

Agents return proof — source records, relationship paths, and scope — so humans and auditors can replay every reply, not just read a paragraph.

Conflicts surface in code

Duplicates, broken links, contradictory relationships, and access-policy clashes are checked automatically — not patched with another prompt. Catch issues before users trust a wrong answer.

Reasoning you can version

Playbooks ship schema, who-sees-what rules, and ingest routing in git — one artifact powers SDK ingest, dashboard, and MCP.

Like Stripe — but for Ontology

Get started

One-step local install

Install the AnythingGraph CLI, run onboard, and get the full stack — dashboard, graph services, and governed MCP — running as a background daemon on your machine.

Connect your AI via MCP

npm install -g @anythinggraph/cli@latest
anythinggraph onboard --install-daemon

Check out the Playbook Generator · Setup guide · MCP connect

Stop paying to reason over data you never needed

99%

Less data in context

Typical account question: hundreds of scoped rows vs. millions of records re-embedded each turn.

10×

Lower inference cost

Graph traversal + capsule scope vs. chunk RAG over full tables on every agent session.

60%

Fewer wrong answers

Early teams using proof, access audits, and conflict checks before replies ship to users.

3 days

To first governed agent

Install a playbook, sync a capsule, connect MCP — vs. months building a custom semantic layer.

Reasoning as Code

From siloed data to grounded agents — in three steps

Encode your domain once, let machine learning build the semantic layer from live data, then connect any agent through MCP or SDKs for answers you can prove and audit.

Three steps from siloed data to grounded agents: data injection from docs and systems, semantic knowledge layer with human in the loop, and AI agents via MCP with governance and explainability

Explainable MCP

What your agents can do

Every capability runs inside one scoped data capsule, with optional per-user access — so answers stay bounded, explainable, and safe.

Answer with proof

Graph Q&A that returns evidence — which records and relationships support each claim.

Who can see what

Show exactly which records a user may access — the same filter applied before the agent answers.

Audit access policies

Explain why access was granted or blocked — including allow/deny rule overlaps per user.

Spot duplicate records

Flag rows that share the same email, ID, or other identifier — before bad merges spread.

Catch conflicting links

Find one record tied to contradictory relationships — e.g. one contact linked to two accounts.

Find broken connections

Surface records missing required relationships — orphans that cause wrong agent inferences.

Compare data scopes

Diff the same entity across two capsules — catch drift between teams, regions, or environments.

Custom graph reports

Run governed analytics on one capsule — custom questions with the same access boundaries.

MCP setup guide · Python, Node & Go SDKs · Dashboard & data-layer API · Try CRM access & data-quality demos

SDK + MCP for builders

Easy to integrate

We focus on developer experience — inject records into a playbook, traverse relationships with proof, and wire the same flows through SDKs, MCP, or REST without rebuilding the semantic layer.

# User asks in Cursor / Claude — a reasoning question
> Who owns Northwind Traders, and who is the contact there?

# Agent calls ask_graph (governed MCP, playbook capsule)
tool: ask_graph
{
  "intent": "follow_relationship",
  "playbook_id": "crm-relationship-access",
  "relationship_name": "owns",
  "company_name": "Northwind Traders",
  "direction": "reverse"
}

# Answer with proof — relationship paths, not prose
alex.ae —owns→ Northwind Traders
  contact_at_account→ Jane Smith

✓ Every claim links to source records in the capsule
✓ Access scoped to subject — no warehouse dump
# Connect MCP: http://127.0.0.1:3333/mcp

Proof graph: alex.ae owns Northwind Traders and Contoso Ltd; Jane Smith and Mike Ross are contacts; opportunities linked to each account — Proof graph returned with the answer — traverse owns, contact_at_account, and opportunity links.

# 1. Inject rows + graph links into an installed playbook
from anythinggraph import AnythingGraphClient, RebacOptions

client = AnythingGraphClient()
ingest = client.connector.ingest(
    {
        "playbook_id": "organizational-graph",
        "source_label": "hr-export",
        "entity_name": "employee",
        "field_mappings": [],
    },
    {
        "records": [{
            "full_name": "Sam Lee",
            "email": "sam@acme.example",
            "corporation_name": "Acme Corp",
        }]
    },
)
print(ingest["relationships_created"])

# 2. Retrieve row-level relationships for that playbook
links = client.data_layer.list_relationships(
    rebac=RebacOptions(playbook_id="organizational-graph")
)

// 1. Data injection — playbook_id scopes ingest + link routing
import { AnythingGraphClient } from 'anythinggraph-sdk';

const client = new AnythingGraphClient();
const ingest = await client.connector.ingest({
  playbook_id: 'organizational-graph',
  source_label: 'hr-export',
  entity_name: 'employee',
  field_mappings: [],
}, {
  records: [{
    full_name: 'Sam Lee',
    email: 'sam@acme.example',
    corporation_name: 'Acme Corp',
  }],
});
console.log(ingest.relationships_created);

// 2. Relationship retrieval — employed_by and other playbook links
const links = await client.dataLayer.listRelationships({
  playbookId: 'organizational-graph',
});

// 1. Inject with playbook_id via Data Injection API
result, err := client.Connector.Ingest(ctx,
    map[string]any{
        "playbook_id": "organizational-graph",
        "source_label":  "hr-export",
        "entity_name":   "employee",
        "field_mappings": []any{},
    },
    map[string]any{"records": []any{{
        "full_name": "Sam Lee", "corporation_name": "Acme Corp",
    }}},
)

// 2. List relationships scoped to the playbook
links, err := client.DataLayer.ListRelationships(ctx, &anythinggraph.RebacOptions{
    PlaybookID: "organizational-graph",
})

# 1. Data Injection API — ingest with playbook_id
curl -s -X POST http://127.0.0.1:8183/ingest \
  -H 'Content-Type: application/json' \
  -d '{
    "context": {
      "playbook_id": "organizational-graph",
      "source_label": "hr-export",
      "entity_name": "employee",
      "field_mappings": []
    },
    "payload": {
      "records": [
        { "full_name": "Sam Lee", "email": "sam@acme.example", "corporation_name": "Acme Corp" }
      ]
    }
  }'

# 2. Data layer — retrieve row relationships for the playbook
curl -s 'http://127.0.0.1:8182/relationships?playbook_id=organizational-graph'

Works with LangChain OpenAI LlamaIndex Anthropic Claude Cursor n8n Microsoft Copilot

SDK reference · REST API · MCP setup

Auto data injection

Inject data — we build the semantic layer

Send records from your systems. Machine learning maps fields, entities, and relationships into your playbook ontology — no manual schema project.

Automatic semantic layer Once data lands, ML links records and relationships so your graph reflects the business — not a pile of disconnected tables.
Human in the loop Business users correct mappings in the landing zone and train the system to get sharper over time — deterministic ML, not LLM guesswork.
Scoped data capsules Each semantic layer stays isolated in its own capsule — finance, sales, and HR never bleed into each other’s graph.

Landing zone & training · Inject data into a playbook

Data capsules

Isolated semantic layers per scope

AnythingGraph generates an isolated semantic layer for each scope and access control — every agent gets its own trusted world model and safe data.

Capsule isolation

Data never crosses scopes — like a capsule. Each playbook is a bounded graph context, not your entire warehouse.

Access control you can explain

Access policies live in the playbook. Policy audits and “who can see what” views show which rules matched — not a black-box filter.

Ship multiple agents safely

Run your own AI agents side by side — each wired to its own capsule — without cross-contamination.

How access policies work · Governed MCP setup · Playbooks · Install guide

From builders

Less hallucination, more trust

“We cut agent hallucinations about 60% and stopped re-embedding two million CRM rows on every question. Evidence and conflict checks in CI — we finally trust what the agent says.”

Early adopter team