Spatial intelligence platform — now in public beta

Turn Code, Memory, Agents, and Projects into Living Spatial Graphs

NSG-ILE combines Nested Spatial Graphs with the Irrational Loom Engine to help teams visualize complex systems, compress AI memory, retrieve source-backed context, and verify every answer through expandable proof paths.

Explore the Platform View Developer Docs See the Product Suite

Loading interactive demo...

Modern systems are too complex for flat tools.

Projects are no longer just files and folders. They are codebases, agents, prompts, documents, runtime logs, decisions, dependencies, issues, branches, teams, and memory. Traditional search and chat interfaces flatten that complexity, forcing AI to guess from incomplete context and forcing humans to trust answers they cannot inspect.

Flat search loses structure.

AI context windows lose source truth.

Agents repeat old mistakes and follow decoy logic.

Runtime behavior disconnects from project memory.

Complex codebases become harder to reason about over time.

NSG-ILE makes complexity spatial, compressed, and verifiable.

NSG maps your systems into deeply nested spatial graphs. ILE compresses those graphs into expandable truth units. NITruth tracks what is current, source-backed, stale, decoy, or provable. Forge lets teams build visually from the graph. Weav brings the intelligence layer into the tools you already use.

Visualize

Inspect systems as nested spatial graphs. Understand structure, relationships, and depth at every layer.

Compress

Reduce context into expandable truth units — Evidence Bundles, Memory Crystals, Loom Seeds, Fractal Layer Summaries.

Retrieve

Pull the smallest useful source-backed context. Expand only when proof demands it.

Verify

Trace every answer to exact sources, source spans, and NITruth manifests. No guessing.

Build

Let humans and agents create from graph-aware context through Forge — with ILE memory behind every action.

Protect

Block stale, decoy, and wrong-path memory using the Shadow Index. Keep AI on the correct route.

The Platform Suite

Six integrated products. One spatial intelligence platform.

NSG Studio

Where systems become visible.

A 3D workspace for inspecting complex systems as nested spatial graphs. Enter layers, open portals, inspect relationships, and understand how every part connects.

Learn more

Irrational Loom Engine

How systems become retrievable, compressed, and source-backed.

Recursive graph memory, fractal compression, expandable recall, source-span verification, and decoy suppression — all in a single intelligence engine.

Learn more

Forge

Where systems are built and modified visually.

The visual build layer for NSG-ILE. Create and evolve systems from graph-aware context, with ILE memory behind every action and NSG for 3D inspection.

Learn more

Weav

Brings NSG-ILE into existing tools.

The slim plugin and extension layer. Get graph memory, source-backed retrieval, NITruth manifests, and ILE context packs inside your existing workflows.

Learn more

Weav Native

Local-first and desktop-native.

Private graph indexing, local NITruth manifests, offline inspection, and native file system integration — spatial intelligence without leaving the machine.

Learn more

NITruth

Every answer has a verifiable source-of-truth layer.

Source-backed truth manifests for AI, graphs, projects, and agents. Declare what is current, stale, superseded, or decoy through .weav/nitruth.json.

Learn more

Core Technology

The architecture that makes spatial intelligence possible at scale.

Fractal Compression

Retrieve a smaller kind of thing.

Memory Crystals, Evidence Bundles, Loom Seeds, and Fractal Layer Summaries replace raw context with expandable proof units.

Expandable Recall

Tiny prompt. Full reachable proof.

Present Recall, Expandable Recall, and Expanded Proof Recall — three layers that keep prompts small while preserving complete coverage.

Source-Span Recall

The right source is not enough. The right claim matters.

Verify that ILE retrieved the exact node, claim, line range, or evidence card needed — not just a file that contains the answer somewhere.

Shadow Index

Anti-context for AI systems.

Hard, soft, and warn suppression modes block known decoys, wrong routes, stale duplicates, and bad agent suggestions without deleting memory.

Phase + Shape Routing

Retrieval should know the state and shape of the problem.

Six shape grammars (Atlas, Torus, Metatron, Merkaba, Flower, Spiral) route retrieval based on graph geometry and workflow phase.

Nested Spatial Graphs

Flat complexity becomes enterable structure.

Every node can contain another graph. Projects, code, runtime, agents, documents, memory — all as layered spatial worlds you can enter and inspect.

NITruth

A truth manifest for projects and agents.

The .weav/nitruth.json file gives a project a structured truth manifest — declaring what is current, superseded, decoy, or provably source-backed.

AI tools, agents, Weav, ILE, Forge, and NSG Studio all share this manifest. Every answer can be traced to an exact source, span, and truth record.

Learn about NITruth

.weav/nitruth.json

{
  "project": "example-project",
  "truthVersion": "1.0",
  "currentSources": [
    "src/api/plans/[id]/index.ts"
  ],
  "supersededSources": [
    "src/api/plans/[planId].ts"
  ],
  "decoyRules": [
    {
      "match": "legacy plan route",
      "replacement": "src/api/plans/[id]/index.ts",
      "mode": "hard"
    }
  ],
  "sourceSpans": [
    {
      "sourceId": "src/api/plans/[id]/index.ts",
      "claim": "current plan retrieval route",
      "spanId": "plans.current.route"
    }
  ]
}

Build with Graph Intelligence

Use the NSG-ILE SDK to retrieve source-backed context, run expandable recall, and verify answers through proof paths.

retrieve.ts

import { ile } from "@nsg/sdk"

const context = await ile.retrieve({
  query: "Which route is the current plan retrieval route?",
  proofMode: true,
  useShadowIndex: true,
})

console.log(context.presentRecall)
console.log(context.expandableRecall)
console.log(context.sourceSpanMatches)

ile.retrieve

Source-backed context retrieval

ile.expandableRecall

Proof-mode expansion

ile.shadowIndex

Decoy + stale suppression

nitruth.validate

Manifest verification

Frequently Asked Questions

What is NSG-ILE?

NSG-ILE is a spatial intelligence platform combining Nested Spatial Graphs (NSG) with the Irrational Loom Engine (ILE). It turns projects, code, agents, and memory into inspectable 3D graphs with expandable, source-backed retrieval.

What is the difference between NSG and ILE?

NSG is the spatial visualization and graph layer — it makes systems visible. ILE is the memory, compression, and retrieval engine — it makes systems retrievable, source-backed, and verifiable.

What is NITruth?

NITruth (NSG + ILE + Truth) is the provenance and truth layer. Through the .weav/nitruth.json manifest, it declares what is current, superseded, decoy, or verifiable in a project — readable by AI tools, agents, and ILE.

What is the Shadow Index?

The Shadow Index stores rules for what not to retrieve. It blocks known decoys, stale sources, and wrong routes without deleting the underlying memory. Rules can be hard (filter completely), soft (downweight), or warn (flag but pass through).

Can I use NSG-ILE with private repos?

Yes. Private graph indexing and local NITruth manifests are available through Weav Native, authenticated API integrations, and enterprise deployment options.

Is Weav a replacement for my current tools?

No. Weav is the slim plugin/extension layer that brings NSG-ILE intelligence into tools you already use — editors, repos, browsers, and agents. You only open NSG Studio when you need spatial inspection.

See your systems as living spatial graphs.

Build, retrieve, verify, and evolve them with source-backed intelligence.

Explore the Platform View Developer Docs