Three planes. One thesis.

Whole worlds grown from a single seed — geology, climate, hydrology, weather, life — deterministic, causal, and queryable by AI. Every place can explain why it is there; every answer an agent gets traces back to the world, never to a guess. The world layer of the Taniwha stack.

• One seed = one planet, reproducible bit-for-bit for a given engine version — no unseeded randomness, no mutable world database
• Causal all the way down: plates → mountains → rain shadows → deserts → the colour of a leaf
• Walk it first-person — vegetation grown live from local soil, moisture and light
• 30+ query verbs over MCP: any AI can interview the world directly
• Rewindable time — “was this valley wet three months ago?” has one true answer

Pono — te reo Māori for truth — applies the Kano contract to code: a deterministic, queryable world derived from a repository’s own history. Agents answer "what changed, what is current, why does this exist" from ground they can cite instead of guessing — and we publish the twin-session experiments that hold it to account. In daily internal use; surfaces to teams through Kete.

• Deterministic projection of git history — no AI anywhere in the derivation
• Identity through change: renames and moves never lose the thread
• "Why does this exist?" resolves to the commit that set it
• Rewindable — the repo at any point in its history, one true answer
• Tested in public: pre-registered twin-session readouts, misses included

A four-layer cognitive architecture — scene tree, world memory, per-agent belief graphs, and composable decision procedures — that gives AI agents real beliefs, memory, trust, and identity. Agents form convictions, lose trust, consolidate memory overnight, and behave like individuals rather than chat turns.

• Per-agent belief graphs with provenance and ambivalence
• Working memory, sleep consolidation, dream replay, and forgetting
• Directional trust that gates testimony and instruction
• Routine compression and surprise-preserving episodic memory
• Every accepted belief change traces to the process that committed it

Deterministic enforcement and audit for AI coding agents at the organisation level — the platform built around the Ārai core, in active development. Org policy across agents, audit retention, query and export, and a pre-computed structural map of your codebase — so your AI agent follows the rules in hour twelve the same way it did in hour one, and you can prove it did. Closed alpha.

• Structural map of every definition, call, and import chain
• Instruction-file rules extracted as typed, queryable constraints
• Pre-flight rule injection via hooks and MCP
• Optional semantic layer (LLM analysis of what code means)
• Corrections persist across sessions as high-trust facts

The guardrail layer of Kete, extracted as a standalone open-source tool (Apache-2.0 / MIT). Ārai parses your instruction files into structured rules, runs as an MCP server so agents can author their own guardrails mid-session, and logs every firing locally so you can inspect what rules fired, on which tools, for which prompts — all running on your machine, no hosted service required.

• Static (AST/regex) code extraction — no LLM cost
• Instruction files → structured, queryable rules
• Pre-flight guardrail enforcement via Claude Code hooks
• MCP server — agents register their own rules mid-session
• Local audit log of every firing (JSONL, no network egress)
• Apache-2.0 / MIT — free for internal and commercial use