Skip to content

The business-state layer for AI

Ask what was true, when it was true, and where the proof lives.

Telha is a single-process tritemporal graph and vector engine with verified generation. It resolves your organisation's state (what is true across documents, systems, decisions, and permissions) and answers with receipts that link every claim back to the exact source bytes.

Get started in 10 minutes Explore the concepts

What Telha is

Search retrieves text. Telha resolves state. Every fact is a versioned node or relationship in a graph, projected out of your documents and systems, and stamped with three clocks so you can ask what was true, as we knew it, on any date. When Telha generates an answer, it plans evidence under a token budget, generates from that plan only, and verifies every claim against the planned source spans before returning it.

  • Get Started

    Install the telha binary, mint an API key, and go from zero to a grounded, verified answer in about ten minutes.

    Quickstart

  • Concepts

    The five ideas that explain almost everything: world state, the three time axes, provenance to the span, confidence & decay, and verified answers.

    Core concepts

  • Developers

    The query DSL, REST / gRPC / MCP surfaces, the TypeScript and Python SDKs, ingestion, and generation with traces.

    Build on Telha

  • Operators

    Deploy, configure, and run Telha: keys and secrets, connectors, backups, retention, upgrades, and troubleshooting.

    Run Telha

  • Architecture

    How the engine works under the hood, drawn from the normative specs: storage, the tritemporal model, vectors, the planner, and verification.

    Engine internals

  • Reference

    The CLI, every configuration key, error codes, a glossary, the spec index, and the product requirements.

    Look it up

The shape of the platform

Telha is one monorepo with three cooperating layers plus client tooling.

flowchart LR
    subgraph clients["Clients"]
      SDKTS["TypeScript SDK"]
      SDKPY["Python SDK"]
      AGENTS["AI agents (MCP)"]
    end
    subgraph app["App layer · TypeScript"]
      MERCATO["Telha app (Next.js)"]
      ENT["Enterprise: field encryption, RBAC"]
      AI["AI assistant"]
    end
    subgraph core["Core engine · Rust (one binary)"]
      REST["REST /v1"]
      GRPC["gRPC"]
      MCP["MCP server"]
      ENGINE["Tritemporal graph + vector engine (RocksDB)"]
    end
    subgraph workers["Workers · Python"]
      DOC["docling · tabular · web · email · code"]
      CONN["connectors: Entra · SharePoint · Exchange · Slack · Salesforce"]
    end

    clients --> app
    app -->|local gRPC| core
    SDKTS & SDKPY --> REST
    AGENTS --> MCP
    workers -->|gRPC worker protocol| core
    REST & GRPC & MCP --> ENGINE
  • Core engine (core-engine, Rust): the tritemporal graph + vector store, the query executor, the memory planner, generation orchestration, and claim verification. Ships as one binary exposing REST, gRPC, and MCP.
  • App layer (app-layer, TypeScript): the Telha app (Next.js) plus the enterprise packages that add field-level encryption and RBAC on top of core.
  • Workers (workers, Python): stateless gRPC clients that parse documents into facts and pull from source systems through connectors.
  • SDKs (sdk): TypeScript (@telha/sdk) and Python (telha) clients over REST and gRPC.

New to Telha?

Read Core concepts first, the whole product follows from five ideas, then run the Quickstart. If you operate the system, jump to the Deployment runbook.

How this documentation is organised

If you want to… Go to
Understand what Telha does and why Concepts
Get hands-on quickly Get Started
Use Telha as an end user, analyst, or steward User Guide
Build an application or integration Developers
Deploy and operate a Telha instance Operators
Learn how the engine works internally Architecture
Look up a flag, command, or error Reference

Written to the system as built

Everything here is verified against the code, the Rust core engine, the SDKs, the Python workers, and the app layer, and against the normative design specs in .ai/specs/. Where a spec's prose and the code disagree, the spec's as-built changelog is the record, and this documentation follows the code.