The governed model layer

One model of your business that you own.

Knowledge graphs from the systems you run and the documents you keep: one governed model, written to the graph engine you choose, with every change recorded — and served the same way to applications, analysts and AI agents.

commerce · model

head 36d20680

commerce.yaml

schema:
  graph:
    vertex_config:
      vertices:
      - name: customer
        properties: [id, name, email, joined_at]
        identity: [email]
      - name: order
        properties: [id, placed_at, total]
        identity: [id]
    edge_config:
      edges:
      - source: customer
        target: order
        relation: placed
bindings:
  connector_connection:
  - connector: orders
    conn_proxy: erp   # a label: credentials arrive at run time

History

  1. add a product category

    f4937dff · AddVertexProperties

    + product.category

  2. key customers by email

    d57451c2 · ReplaceIdentity

    customer: id → email

  3. record when a customer joined

    edeca470 · AddVertexProperties

    + customer.joined_at

Written to

Neo4jArangoDBPostgreSQL+ 5 more

Read by agents over MCP: read-only, capped.

A real model in GraFlo's open format, and the history it was built by. Commit ids are content hashes.

Keep your databases and your pipelines. GrowGraph is the model above them.

Reads from
SQL tablesCSV · JSON · ParquetAPIsKafkaRDFPDF · Office · HTML
Writes to
Neo4jArangoDBTigerGraphFalkorDBMemgraphNebulaGraphPostgreSQLFiles

The problem

Graph pilots stall at the second source.

The first source makes a demo. The second brings its own idea of who a customer is, a schema that keeps changing, and documents that disagree with the systems.

Ownership

“Our semantic layer lives inside one vendor.”

The model is a file you own, with no credentials in it. It targets eight engines, and the core that reads it is open source.

Change

“We can’t change the graph once it’s in production, so it rots.”

Every change is a typed operation in a recorded history: verified by content hash, undone exactly where an exact inverse exists, merged across branches.

Agreement

“The manual says one thing, the monitoring says another.”

Documents and systems land in one model under one identity, and each claim keeps where it came from.

How it works

One model in the middle

Every source maps onto it, every consumer reads from it, and every change to it is recorded.

Your systemsSQL tables · files · APIs · streamsYour documentsPDF · Office · HTML · MarkdownThe modelone file you own, written to any of eight enginesschemaentities and relationsidentities, typed fieldsingestion modelhow each sourcemaps onto the modelbindingswhere each source livesby label, no credentialsrecorded historyedeca470d57451c2f4937dffeach change typed and hashedGraph enginesNeo4j · ArangoDB · PostgreSQL · +5Analysts and applicationsone model, one meaningAI agentsover MCP · read-only, capped
  1. 01

    Declare

    Write the model down once: entities, relations, identities, and how each source maps onto them. One file, no credentials, no per-database code.

  2. 02

    Change

    Evolve it as the business does. Each change is a typed operation with a content hash, reviewed and merged like code.

  3. 03

    Serve

    Write to the graph engine you already run, and serve the same model to analysts, applications and AI agents — read-only by default.

Who it is for

For teams that have to explain an answer.

01

Teams whose systems and agents must answer what happened in an operation.

Tickets, monitoring, registers and runbooks each hold part of the story. One model, with one identity for each thing they describe, lets people and agents read all of it — and see where each part came from.

02

Teams who must show what went into a computed number.

A figure is only as defensible as the chain behind it. One declared model of sources, entities and changes lets you show which inputs a number rests on, and what changed since.

For AI agents

The same model, served to your agents

An agent reads the model your people read, through a governed surface: bounded, read-only, and capped before anything reaches the database.

Bounded context

A budgeted slice of the model, sized to the agent’s context window, with what was left out reported.

Read-only by default

Every connection is read-only under hard caps on traversal depth, result size and time, enforced before a query reaches the database.

One surface, eight engines

Schema, traversal and capped queries over MCP, the same across every supported backend. When the model changes, the change is visible to the agent.

How the context plane works →

Open source

Built on code you can inspect

The model layer runs on two open-source projects. Run them yourself before you ever talk to us.

GraFlo

Apache-2.0

The model: declare it, change it with a recorded history, write it to any of eight backends.

OntoCast

Apache-2.0

Documents read into facts against your ontology, with provenance for every fact.

$ pip install ontocast

PyPIDocsGitHub

Documents to RDF without running anything: the OntoCast API Platform is open in early access.

Show us the question your data cannot answer yet.

A short call, a walkthrough on your kind of data, and an honest answer on fit.

Request a demo