Pathorah

Boundary Intelligence

Turn expertise into AI that knows where it must stop.

Chat made knowledge conversational. Pathorah makes expertise executable, governable and verifiable — every answer carries its evidence, every action needs authority, and every run leaves a signed receipt.

Path Run
claims-review · v3.2 · signed
  1. Authenticate principal and delegation chain

    done
  2. Resolve signed Path version and revocation state

    done
  3. Retrieve evidence from approved sources

    3 citations · fresh

    allow
  4. Model proposes: update the case record

    Approval bound to proposal hash

    approval
  5. User asks for a final legal ruling

    Outside competence boundary

    refused
  6. Evidence Packet signed and audit appended

    done

The model proposes. Deterministic infrastructure authorises.

The gap

Generic AI answers questions. Real work needs boundaries.

Models, agents, RAG and tool calling are becoming commodities. What is still missing is a system that represents and enforces the limits of consequential work.

Expertise is encoded too weakly

Prompts and documents capture instructions — not evidence thresholds, exceptions, stopping rules or legitimate disagreement between experts.

Security still lives inside the prompt

Injection, excessive agency and data leakage cannot be solved by asking a model to behave. Enforcement has to sit outside the reasoning loop.

Demos are not operational assurance

A polished demo hides variance, unsupported claims and unsafe partial completion. Consequential work needs tested, reproducible runs.

Memory without governance compounds errors

Stale or poisoned memory silently shapes future runs unless it has type, source, scope, expiry and a visible correction path.

How it works

A closed loop from expert teaching to proof-carrying execution.

No single step is the product. The combination is.

  1. 01

    Teach

    Experts explain, demonstrate, correct and attach evidence. An interviewer asks what changes the decision, and when a human must take over.

  2. 02

    Compile

    Foundry compiles the teaching into a Path — a typed, model-neutral decision system with an explicit Boundary Contract.

  3. 03

    Test

    Exception Lab generates edge, adversarial and counterfactual cases. Every declared boundary gets at least one refusal test.

  4. 04

    Enforce

    Runtime executes through an external boundary firewall. Policy is decided before every privileged crossing, not once per run.

  5. 05

    Prove

    Each run produces a signed Evidence Packet: claims, sources, policy decisions, approvals, model versions and action receipts.

  6. 06

    Improve

    Outcomes become candidate changes. Production behaviour only changes through a new, reviewed and immutable release.

The Boundary Stack

Every Path declares what it knows, may do, must prove and must refuse.

Boundaries can be inherited from the organisation, jurisdiction or domain — but the effective boundary is resolved before anything runs.

  1. 01

    Purpose

    What outcome is this Path authorised to pursue?

  2. 02

    Competence

    Which cases are inside, conditional or outside scope?

  3. 03

    Schema

    Which inputs and outputs are valid?

  4. 04

    Knowledge

    Which sources may support which claims?

  5. 05

    Evidence

    What level and freshness of proof is required?

  6. 06

    Uncertainty

    When must the Path expose doubt or refuse?

  7. 07

    Identity

    Who is acting, for whom, under what delegation?

  8. 08

    Data

    What can be read, derived, stored or transmitted?

  9. 09

    Memory

    What can persist, where, and for how long?

  10. 10

    Tool

    Which capabilities can be invoked, with which arguments?

  11. 11

    Action

    Which real-world changes may be made?

  12. 12

    Safety

    Which harms require additional controls?

  13. 13

    Jurisdiction

    Which law, policy or residency rule applies?

  14. 14

    Resource

    What time, compute and external activity are allowed?

  15. 15

    Rights

    Who owns, licenses and may transform the capability?

  16. 16

    Version

    Which dependency versions and changes are permitted?

  17. 17

    Inter-agent

    Which agents may delegate to or trust one another?

  18. 18

    Information flow

    Which inputs may influence which decisions and actions?

  19. 19

    Execution integrity

    Can the runtime prove what actually executed?

  20. 20

    Entitlement

    Who may consume the capability, and under which duties?

  21. 21

    Multi-party

    Which parties must jointly authorise or attest?

  22. 22

    Redress

    Who may challenge, correct, pause or seek reversal?

Platform

One small, deliberate product system.

Author

Foundry

Teach, compile, evaluate and release Paths — without writing prompt graphs.

Use

One

A workspace that turns a request into a plan, the right interface, evidence and approvals.

Execute

Runtime

Model- and tool-independent execution with checkpoints, budgets and safe failure.

Govern

Trust

Identity, policy, evidence, audit, replay and incident control — independent of the model.

Roadmap

Exchange

Distribution of approved Paths with passports, rights and revocation — never a prompt shop.

Proof-carrying runs

Every consequential run can show its work.

The Evidence Packet is exportable as structured data and readable as a short human report. It never exposes secrets or hidden chain of thought.

  • Claim-level evidence with freshness and conflicts
  • Effective boundary and every policy decision
  • Model, tool and knowledge versions used
  • Approvals bound to the exact proposal hash
  • Action receipts and compensation paths
  • Tamper-evident, hash-chained audit trail
{
  "schema": "pathorah.evidence_packet/v1",
  "run": { "path": "claims-review", "version": "3.2.0", "status": "completed" },
  "claims": [
    { "type": "fact", "status": "verified", "support": ["ev_18a", "ev_2c4"] }
  ],
  "decisions": [
    { "operation": "case-system:draft-update",
      "result": "require_approval",
      "reason": "reversible_external_change" }
  ],
  "actions": [
    { "class": "reversible", "approval": "bound:sha256:9f2c…",
      "verification": "verified", "compensation": "available" }
  ],
  "integrity": { "audit_head": "sha256:4be1…", "signature": "ed25519:…" }
}

Principles

Built on product law, not marketing.

Bounded before autonomous

More agency demands stronger identity, evidence and action requirements.

Proof before persuasion

Unsupported confidence is treated as a defect.

Portable before vendor-bound

Path meaning stays model-neutral; providers sit behind adapters.

Reversible before irreversible

Preview, draft and staged actions first; irreversible ones need narrow authority.

Plural expertise

Legitimate expert disagreement is preserved with conditions — not averaged away.

No silent mutation

Behaviour changes only through an observable, evaluated and approved release.

Who it serves

A clear promise to each role.

Expert
«Teach once; preserve how you actually think.»
Operator
«Get work completed without surrendering control.»
Organisation
«Scale expertise without losing governance.»
Developer
«Build once across models and tools.»
Reviewer
«See why this was allowed and whether it is supported.»

Why not just…

Where Pathorah is different.

Chat assistants
Move from conversation to completion, with visible boundaries, proof and exact action receipts.
Agent builders
Let an expert teach tacit decision boundaries instead of becoming an automation engineer.
RAG and search tools
Link sources to claims, decisions and actions — and refuse when evidence is not enough.
Prompt marketplaces
Distribute tested capability with identity, limits, rights and revocation.

Design partners

We are selecting the first vertical slice.

We are looking for one domain with real experts, inspectable evidence and a reversible first action. Tell us about yours.