Meaning fused
into data.

Every value carries its type, meaning, validation, and provenance. Write YAML. Get a queryable, renderable, git-sealed Holograph.

The Syntax

YAML, reimagined

Declarations

Base · Declare · Use · Entangle

The Cascade

Resolution & composition

HQL

Path-based queries

Git-Grounded

Cryptographic proof

Ecosystem

MCP · CLI · LSP · WASM

01 — The Language

YAML, reimagined.

Two deliberate breaks from YAML. No quotes needed — the parser is contextual. Every value knows what it is.

Shorthand Values

No quotes. The parser knows it's text and ends at the newline. Inline fields compose as rules on the same value.

Meaning@GitHub: GitHub is a platform
    Category: /VCS/GitHub
    purpose: The platform for version control

repo_url@url:
    regex: https://github.com/[^/]+/[^/]+
    min_length: 20
    max_length: 100

Composable Rules

Inline fields aren't metadata — they're composable rules. Convert, min, max, regex — all compose through the cascade.

the_answer:
    Convert: Number
    value: 42
    min: 42
    max: 43

# Fully typed, validated, constrained.
# No schema. The rules ARE the data.

Naming convention IS the type system. PascalCase = structure (SpaceBond). snake_case = data (ValueBond). One rule eliminates an entire category of confusion.

02 — The Type System

Four Declaration Kinds

Every point is declared in one of four ways. Declare is an upsert — composes on top of whatever exists by name.

Base — Type

Default rules for all instances. Fills any slot — Space, Meaning, Value — using just the shape name as a key.

ValueBond@url:
    regex: ^https://[^\s/$.?#].[^\s]*$

ValueBond@git_hash:
    Convert: Text
    regex: ^[a-f0-9]{40}$
    exact_length: 40

Declare — Type@Name

Named instance with @. Upserts on top of the cascade. Inherits all rules, overrides selectively.

SpaceBond@Repository:
    repo_url@url:
        regex: https://github.com/[^/]+/[^/]+
        min_length: 20

Use — Type@: Reference

Point to an existing instance. Inherit meaning, validation, purpose — no duplication.

Meaning@Boolean:
    Mapping:
        -1.0: False
            purpose: Absolutely FALSE!
        1.0: True
            purpose: Absolutely TRUE!

Entangle — Type~Name

Extend across composition boundaries. Context-wide entangle stack — DFS order, grouped by depth. Deepest wins.

Config~BaseService:
    timeout: 30s
    max_retries: 3

Real Example — from composition.kant

⛩️:
    Meaning@Boolean:           # Declare — named Meaning
        Mapping:
            -1.0: False
                purpose: Absolutely FALSE!
                Convert: Number
                value: 0
            1.0: True
                purpose: Absolutely TRUE!
                Convert: Number
                value: 1

    Meaning@GitHub: GitHub is a platform  # Shorthand!
        Category: /VCS/GitHub

    SpaceBond@Repository:       # Declare — named SpaceBond
        repo_url@url:             # Nested Declare — uses @url base
            regex: https://github.com/[^/]+/[^/]+
            min_length: 20

Boundaries build the Declared Language — the substrate that contexts start from, use, adapt, extend, evolve. Not a schema. Structure, feedback, entanglement, emergence.

03 — The Key Innovation

The Cascade

When a Point seeks resolution during the tree build, it looks up what's already processed — cascading through targeted Boundary layers.

Resolution Priority

For a SpaceBond (wraps Meaning + Space), just the key in Context triggers a priority-ordered seek:

1

Primary Match

SpaceBond@Repository found in ancestry resolution path. If found, stop. It already did the same seek.

2

Wrapped Shapes

Declare match for a wrapped slot (Space or Meaning). Stops for that slot, continues for others. Layers below Primary.

3

Base Match

All 3 slots filled with Base — just the shape name as a key. Still seeks Declare. Base layers below Wrapped. Everything composes.

Entangle Stacking

Type~Name entangles across the whole context. DFS order, root to leaf, grouped by depth. Deepest wins.

Stack: Operator

K-way merge inside a file. -1 to 1 floats control priority.

Stack: [base, overrides, secrets]

Resolve Injection — composition.kant

⛩️:
    SpaceBond@Repository:
        repo_url@url:
            regex: https://github.com/[^/]+/[^/]+

⛩️ Production:                  # Scoped Boundary!
    SpaceBond@Repository:
        pager_duty_url@url:
            regex: ^https://[^/]+\.pagerduty\.com

Production:
    Repository:              # ← triggers cascade seek
        repo_url: https://github.com/composable-delivery/Typesynth
        pager_duty_url: https://example.pagerduty.com/services/PABC123

Development:
    ⛩️:                        # Nested Boundary!
        SpaceBond@Repository:
            mode: dev
                Meaning: Development Mode
    Staging:
        Repository:
            repo_url: https://github.com/composable-delivery/Typesynth-Staging

Scoped Boundaries (⛩️ Production:), nested Boundaries, resolve matches that inject whole subtrees. Production's Repository inherits repo_url from the root Boundary AND pager_duty_url from its scoped Boundary. No schema — just structure and emergence.

04 — Navigation

HQL — Holograph Query Language

Path-based queries with shape filters and layer predicates. Like a filesystem, but meaning-aware.

/**

All points recursively

/Production/**[ValueBond]

All data values in Production

/Production/**/Repository

Deep search for repositories

/**[SpaceBond]

All structural containers

/Config->.database_url

Follow reference to target

/**@changed

Everything that changed in merge

Layer Predicates

@mainBase layer
@extExtension
@resolutionResolved refs
@changedDiffs
@addedNew points
@mergedMerge ops

Context Efficiency for AI

Query just what you need instead of loading everything. HQL + Jinja templates let models navigate huge compositions without flooding context.

This is how kantext-mcp gives Claude depth without noise.

Templates & Projections

Four projections: Declared (clean, re-groundable) · Decomposed (DFS linear) · Composed (lock file) · Internal (debug). Models write Jinja to select exactly what they need.

{% for svc in ctx.Production.Services.values() %}
{{ svc.name }}: replicas={{ svc.replicas }}
{% endfor %}

{% set dbs = query('/Production/**/Database') %}
Databases: {{ dbs | length }}

05 — Provenance

Git-Grounded

Every composition is cryptographically sealed. The artifact IS the proof. Full round-trip: compose → seal → commit → rehydrate → compose again.

Write

Clean .kant files. Git-friendly.

Seal

blake3(WHERE + WHAT + WHO).

Commit

Push. Auto attribution.

Rehydrate

Load. Compose again.

Ground: blake3(WHERE + WHAT + WHO)
WHERE = Connector (git repo, HTTP, in-memory)
WHAT = Frame (composed content)
WHO = Identity (author, timestamp, commit)

Immutable. Cryptographically certain. The proof travels with the data.

06 — Integrations

One Language, Every Surface

Same layers, same meaning, same provenance — VS Code, terminal, browser, or AI agent.

MCP Server

The highlight. Compose, query, render, seal — directly from Claude or any MCP agent.

Claude · MCP · LLM

CLI / TUI

Compose, validate, query, render. Local-first. Full REPL.

Compose · Query · Render

LSP Server

Syntax highlighting, completion, diagnostics, hover docs.

VS Code · Neovim · Emacs

HTTP Server

Tower/Axum. REST + streaming. Auth, metrics.

Deploy as a service

WASM

Client-side composition. Zero latency.

Browser · WebAssembly

Python (Coming)

PyO3 bindings. ctx.Production.Services

Ergonomic · Auto-unwrapping

Built on Succinct Data Structures

ver-vecs — BpTree, WaveletMatrix, EliasFanoVec. Maps orthogonal dimensions that align and even entangle. Constant-time navigation across the full Holograph.

Try it now.

Real composition engine compiled to WASM. Write Kantext, see the Holograph build live.

Open PlaygroundArchitectureGitHub