Submit entities. Neural Fabric derives their connections.

One shared database for your apps, agents, and business knowledge.

Bring business information into one database. Work with it through Qora, monitor changes with Signal, and connect your apps and agents through MCP.

Your model. Your API key.

Anthropic / Claude OpenAI xAI / Grok Moonshot AI / Kimi DeepSeek

Powers Qora and classification

Qora

Ask, explore, build

Signal

Monitor and understand your business

Activity

Trends

Anomalies

Your apps & agents

Clients access Neural Fabric

Use the apps you already work with

Claude ChatGPT Custom agents

Native MCP Find, read, update

Qorbit Neural Fabric

One shared database for your apps and agents

Fabric Engine

Classify information. Derive connections. Preserve history.

Across industries and information types.

Shared entities, relationships, and history

Operations Finance Sales Manufacturing People Your domain

One shared database across business domains

Governance & provenance Lineage Access control Auditability

Business information classification Authorized retrieval & ingestion

Business information

Information from across your business.

Files & media

Documents, photos, voice notes, and other files

Structured data

Tables, spreadsheets, business records

Business apps

Drive Slack QuickBooks

and connected applications

Change the model behind Qora. Keep your business knowledge in Qorbit.

Follow an entity through the Fabric.

This sample uses a sales order and quotation to demonstrate the API. The same entity, connection and history operations apply across supported business domains and information types.

This example follows a sample sales-order entity: find it, inspect its connection to a quotation, update a property, and read the resulting history.

Create the sample entity in the quickstart, then use its returned ID below.

Requests below are MCP tool arguments. Results are illustrative, not responses from a live customer tenant.

Replace YOUR_SALES_ORDER_ENTITY_ID with the identifier returned by fabric_add.

Neural Fabric runs on Qorbit’s proprietary database kernel. It uses mathematical coupling to identify related entities and supports traversal across their connections. Harmonic matching surfaces entities associated with a seed so developers can investigate the relevant relationships and inspect their basis.

Relationship computation is separate from model-assisted classification and answer generation. The configured provider prepares incoming information where classification is required; answer mode uses a model to compose a response.

{
  "query": "SO-03242607",
  "entityType": "SalesOrder",
  "detail": true,
  "limit": 5
}

{
  "mode": "root",
  "rootEntityId": "YOUR_SALES_ORDER_ENTITY_ID",
  "includeExplanations": true,
  "depth": 2
}

{
  "entityId": "YOUR_SALES_ORDER_ENTITY_ID",
  "edits": [
    {
      "op": "set",
      "path": "/properties/status",
      "value": "released"
    }
  ],
  "reason": "Release sample sales order",
  "actor": "docs-sample"
}

{
  "entityId": "YOUR_SALES_ORDER_ENTITY_ID"
}

How it works

Agents and apps write entities. The Fabric derives the connections, serves the reads, and keeps the history.

Entities

A write is structured data through fabric_add, or a file. Supported files, and which of them yield text, are listed in Supported formats.

The classifier on your configured provider turns that input into a type, properties, and a role for each value. A role is identity, reference, or descriptive. Identity means the value identifies this entity. Reference means the value points to another entity. Descriptive means the value describes this entity. For a PNG or JPEG, the classifier reads the image at write time, and the words and description it records are the visual transcript on the entity. If you do not supply an ID, the ID is derived from the values marked identity, so the same record written again updates that entity.

You do not declare a schema first, and you do not define an edge type. A registered type is a stored definition for a kind of entity. The classifier may use one as a hint. You do not have to create one, and a type that is not registered is still accepted.

Derived connections

No write creates a connection. The Fabric derives connections from what is stored. A sales order that carries the number of a stored quotation is connected to that quotation because the value is confirmed on both sides. Each entity is also encoded into frequency bands from its properties and text, and entities whose bands overlap strongly enough are connected by harmonic coupling. Every connection carries its basis, the shared identifier or the shared bands. fabric_graph returns the connections and their basis for one entity's neighborhood, for the tenant, or for the entities reached from a seed. The graph in the app is a view of the same stored entities and the same derived connections.

Provenance

Every write appends to the entity's history: the actor recorded on the write, the time, and the operation. For an edit, the history includes the property values before and after the change. A delete is recorded as an event, and then the entity is removed. The event stays in the trail. An entity extracted from a document keeps its link to that document. fabric_read_source returns the stored source: extracted text for a document that has it, and the original image for a PNG or JPEG, along with the visual transcript stored on the entity. fabric_provenance reads the trail.

Where a model is used

The kernel does the search. In both modes, harmonic coupling, frequency mathematics, and identity resolution rank and retrieve the entities.

The classifier on your configured provider runs on a write, and when an edit changes properties. It produces a type, properties, and a role for each value. For a PNG or JPEG, the write-time call reads the image.

In fabric_search answer mode, a model turns the question into a specification, and a model writes the reply in plain English from the entities the kernel retrieved. Match mode does not call a model.

In conversation, a model turns a message into a tool call and writes the reply in plain English from what the tools returned. If the message includes a PNG or JPEG, that model sees the image. The transcript stored on the entity comes from the classifier.

When a conversation searches the public web, a model does that lookup. That lookup is not a Fabric search.

Identity resolution, connection derivation, match-mode search, fabric_graph, fabric_list, fabric_read_source, and fabric_provenance do not call a model. The classifier records roles. The kernel decides the connections.

Available operations

MCP tools on the same business database. Schemas, modes, parameters, and complete response examples are in the MCP tool reference.

Technical evidence

Figures below are from the T3-lite synthetic-corpus report (60,610 entities, 2026-06-15). They measure kernel retrieval and harmonic-graph identity quality on that workload. They are not classifier accuracy, not live customer documents, and not exact-passage retrieval.