Concept graphs, the SeKondBrain way
Concept graphs · SeKondBrain edition

Created by Benjamin J Brey, CFA

Chief Strategist, SeKondBrain.ai

b@sekondbrain.ai

A concept graph is a spreadsheet with arrows. Here is how SeKondBrain builds one.

The same seven-step pipeline as the general primer, told through Cognition OS, Kemory and SeKondBrain’s open-source work: 36 public sources, each linked to the step it supports, and a dated list of recent projects.

36Sources
7Pipeline steps
11Public repos
10Recent projects
01 · SeKondBrain as a concept graph

Everything public, as one graph.

Every public source behind this primer, the site that publishes it, the pipeline step that cites it, the ideas and technologies it names, the product it documents, and the recent initiatives that involve it. Drag, zoom, hover to see neighbours, or click a source to open it.

99Nodes
258Edges
8Node types
Drag nodes · scroll to zoom · click for details
Ontology termspublishedBy joins a source to its site. mentions joins a step to the sources its section links, and a source or step to the terms it names. about joins a source to the product or programme it documents.
Plain labels“next step” and the dotted loop come from the pipeline diagram. “involves” joins an initiative to its programme and public sources; “touches” joins it to the steps it bears on.
How it was builtRead straight from the source table, the primer text and the recent-projects list. A term is linked only where its name appears in the text; nothing is inferred.

Terms are matched on each source’s catalogue entry (title and note), not the full page, so a source can teach more than its links show. The full graph is also available as sekondbrain_kg_graph.json.

02 · The idea

Spreadsheets, with arrows.

A concept graph is a spreadsheet with arrows.

Each row is a thing you care about: a person, a team, a feature, a document. Each column is a fact about that thing. The extra piece, the part a table cannot say cleanly, is a named arrow from one row to another: this feature has that requirement; this document was derived from that call.

This edition teaches the same construction pipeline as the general primer, but tells it through how SeKondBrain builds its own graphs. Every claim links to something public: the Cognition OS documentation, the Kemory documentation, the SeKondBrainAILabs GitHub organisation, or sekondbrain.ai. Nothing here comes from private repositories or internal notes.

Why a table is not enough

A table holds rows well. It struggles when:

  • The same thing arrives under three names from three systems, and your joins miss each other.
  • A fact has a direction and a type (contains, derived from, similar to), not just a value in a cell.
  • The question is a walk, not a lookup: which requirements does this journey depend on, through which features?

SeKondBrain’s answer is a concept graph. Its home page puts the idea in one line: extract the meaning underneath your information, the people, decisions and ideas rather than just the words, and connect it into a living map. Its research page makes the argument at length: models work at the level of tokens, retrieval works at the level of documents, but knowledge lives at the level of the concept. The Wrong Zoom Level (Sachin Dev Duggal, April 2026) puts the same idea as a matter of scale: tokens are too small to think with, files are too big, and a concept is the unit that survives a change of wording or container.

That is why this edition says concept graph: SeKondBrain’s take on the knowledge graph, with facts organised around persistent, versioned concepts that carry their own time, provenance and certainty. Concept-Grounded Attention calls this a Concept Lifecycle Model. Outside tools and guides still say “knowledge graph”; the construction steps are the same.

There are two common ways to write a graph down: RDF triples, or a property graph (nodes with labels, relationships with types, properties on both). Cognition OS is a property graph served over REST: one isolated graph per organisation, retrieval by traversal, vector similarity and full text, fused and ranked. It never calls a language model directly; extraction is delegated to a separate Reasoning engine, which keeps the graph a clean record of what is known and keeps model choice out of the data layer. That split, a graph that records and a reasoner that proposes, runs through every step below.

03 · The construction pipeline

Questions first. Then build in order.

Do not start by pouring text into a model. Start with the questions, then build in this order:

0
Step 0 · Questions

Decide what the graph is for

A first graph fails most often because nobody wrote down what it must answer. Five to ten questions is plenty, and anything no question needs stays out for now.

Cognition OS makes this choice explicit at the very first call. When a tenant is provisioned, it declares the shape of its graph: an archetype (its own subtype tree), a shipped template, or a stock graph_type such as product, people, code or concept. The same service backs people graphs, product graphs and code graphs because the purpose is chosen per tenant, not per deployment. Pick the shape that matches your questions before you write a single node.

Do not plan to capture everything. Context Graphs Are the Bridge (January 2026) argues that organisations forget paths, not facts: the why is the route a decision took. Capture that route where decisions already happen, at escalations, approvals, overrides and exceptions, in thin slices, and let the rest go.

Source · Cognition OS quickstart

1
Step 1 · Model

Pick the nouns, the verbs, and the key

The nouns become node types, the verbs become relationship types, and every node needs a stable identifier.

Cognition OS roots every node at exactly one of five primitives: SuperRoot (the tenant anchor), Person, Organisation, Concept and Artefact. Tenants do not invent roots; they declare subtypes beneath them, written as a label chain such as Concept:Skill:SkillChain or Artefact:Document:Email. Match Concept and you get every skill, feature and requirement; match SkillChain and you get exactly that, with no schema migration.

Relationships come in named families rather than a vague CONNECTED_TO: hierarchy (PARENT_OF, CONTAINS, SUBCONCEPT_OF), composition (HAS_FEATURE, HAS_REQUIREMENT) and association (RELATED_TO, DERIVED_FROM, USES_CONCEPT). Edges carry properties, such as a match score and its source, so provenance lives on the arrow itself. The ontology modules (product, code, people, reasoning) are composed per tenant, and patterns that prove themselves across tenants can be promoted into the shared vocabulary, so it grows from use rather than guesswork.

Some facts have more than two parts: an agent used a tool on a file in a session and produced an outcome; a funder put an amount into a company on a date, according to a source. Mathematicians call that a hyperedge. Rather than forcing it into pairs, give the event its own node and hang each part off it, the practical bridge before a full hypergraph that Neurosymbolic Is a Direction of Travel (July 2026) recommends: “If the graph cannot represent the shape of the thing that happened, the system will eventually misremember it.” The public Cognition OS docs do not describe an event root, so treat this as a pattern, not a feature: an event subtype in a label chain, or in plain Cypher, an intermediate node as in Neo4j’s Modeling designs. TypeDB’s The n-ary relation shows the native alternative: one relation with as many named roles as the fact needs.

Source · Cognition OS data model

2
Step 2 · Extract

Pull facts out of your sources

Structured sources map straight to nodes and edges. Text needs extraction, and extraction output is a draft, not a fact.

Submitting a document to Cognition OS runs a four-agent pipeline: Scribe extracts, Architect structures, Synthesizer integrates and Interrogator validates, alongside a four-phase progressive extraction: entities, then relationships, then hierarchy, then quality. The model calls themselves live in Reasoning, which routes text to a handler, extracts typed slots and checks the result against a schema before it returns: validated JSON, not a paragraph to parse.

On the memory side, the public Kemory clients show extraction at the edge. The Kemory plugin for coding agents stores a redacted digest of your own prompts at the end of a session, and commits on 13 to 15 November 2026 widened the redaction to more kinds of API key. The Hermes provider captures what you type with secrets redacted, into a private session namespace, and posts only after a few new prompts have accumulated.

Source · Cognition OS ingestion pipeline

3
Step 3 · Resolve

Make one node per real thing

Three spellings of one entity must become one node, and one node that conflates two things must be split.

Cognition OS starts with identity: supply your own id and a write merges on (id, org_id) rather than duplicating, so a replay is safe. For free text, /v1/concepts/resolve runs a three-tier cascade: exact anchors already in your graph, their neighbours in the hierarchy, then vector discoveries for what the first two missed. Each tier fails soft, so one backend being down still returns useful matches. For clean-up, a dedup endpoint collapses duplicates sharing an id, and the documentation says to always dry-run it first.

Source · Cognition OS concept resolution

4
Step 4 · Validate

Make the graph refuse bad data

A graph that accepts anything soon contains everything. Validation belongs at write time, not in a quarterly clean-up.

Cognition OS refuses quietly wrong writes with explicit errors: an unknown node_type, rel_type or graph_type returns 400, because the value is not in your declared vocabulary. Circular PARENT_OF or CONTAINS writes are rejected before insertion. Subtype names are validated when the archetype is provisioned. An analyser checks contents against the schema, and extractions below a confidence threshold are staged for human review rather than written blind.

Source · Cognition OS errors and guards

5
Step 5 · Store

Pick one place and stay there

Choose one store per graph, write to it idempotently, and keep tenants apart below the query layer.

Cognition OS keeps one isolated graph per organisation, selected by a header; every tenant-scoped read carries an organisation filter, so cross-tenant reads are indistinguishable from “not found”. Bulk endpoints exist for volume, and because writes merge, a replayed batch converges rather than duplicating. Deletes are soft by default. Readiness stays 503 until storage and search are healthy, and a failed event lands in a dead-letter queue you can replay. Cognition OS is licensed and provisioned rather than self-serve; if you want something you can run yourself today, Kemory Community Edition is an Apache-2.0 memory server for agents (Postgres with pgvector, REST and MCP) that starts with two npx commands.

Source · Cognition OS data and isolation

6
Step 6 · Query

Ask your step-0 questions

Run the questions you wrote at step 0. If an answer is wrong or missing, go back to the model, not the prompt.

Cognition OS offers neighbours, archetype-aware entity search ranked by how many of your concepts an entity actually connects to, and unified search across graph, vector and full-text backends, where every result reports the backend that produced it and a match_explanation, so you can show a user why something matched. Kemory’s retrieval engine fuses semantic, lexical and blind-index legs by rank, then re-ranks on five signals, one of which is proximity in the memory graph. Its most useful advice is about phrasing: a query written in the vocabulary the memory was written in beats a paraphrase, and kemory_ask returns the evidence alongside the answer.

Source · Kemory retrieval

04 · Worked example

A tiny product graph. Three nodes, two arrows.

Written the way the Cognition OS quickstart shows. A journey has a feature; the feature has a requirement. Host, organisation and token are issued when a tenant is provisioned, so the placeholders stay placeholders.

Declare the shape. Provision once with the stock product shape. The call is idempotent, so it is safe on every boot.

BASH
curl -X POST https://<YOUR_COGNITION_HOST>/v1/tenants/provision \
  -H "Authorization: Bearer <YOUR_SERVICE_TOKEN>" \
  -H "X-Org-Id: my-team" \
  -H "Content-Type: application/json" \
  -d '{ "tenant_id": "my-team", "graph_type": "product" }'

Write the nodes with your own ids. One bulk call; graph-level fields sit on the envelope, and a replay converges rather than duplicating.

BASH
curl -X POST https://<YOUR_COGNITION_HOST>/v1/graphs/nodes/bulk \
  -H "X-Org-Id: my-team" \
  -H "Content-Type: application/json" \
  -d '{ "graph_type": "product", "graph_name": "roadmap",
        "nodes": [
          { "id": "journey-find-decision", "name": "Find a past decision", "node_type": "Journey" },
          { "id": "feature-saved-search",  "name": "Saved searches",       "node_type": "Feature" },
          { "id": "req-permissions",       "name": "Results respect permissions", "node_type": "Requirement" }
        ] }'

Draw the arrows. One call per edge, from the composition family. The second edge carries its own provenance.

BASH
curl -X POST https://<YOUR_COGNITION_HOST>/v1/graphs/relationships \
  -H "X-Org-Id: my-team" \
  -H "Content-Type: application/json" \
  -d '{ "source_id": "feature-saved-search", "target_id": "req-permissions",
        "rel_type": "HAS_REQUIREMENT",
        "source_label": "Concept", "target_label": "Concept",
        "properties": { "source": "spec-review", "score": 0.9 } }'

Check before you clean. Dry-run the dedup sweep; a clean graph reports zero removed.

BASH
curl -X POST https://<YOUR_COGNITION_HOST>/v1/graphs/dedup \
  -H "X-Org-Id: my-team" \
  -H "Content-Type: application/json" \
  -d '{ "graph_name": "roadmap", "dry_run": true, "batch_size": 100 }'

No tenant? Try the same shape locally. The public docs do not name the database behind Cognition OS, so this is an illustration, not its internals: the label-chain idea written in Cypher for any property-graph database.

CYPHER
MERGE (j:Concept:Journey {id: "journey-find-decision"}) SET j.name = "Find a past decision"
MERGE (f:Concept:Feature {id: "feature-saved-search"}) SET f.name = "Saved searches"
MERGE (r:Concept:Requirement {id: "req-permissions"}) SET r.name = "Results respect permissions"
MERGE (j)-[:HAS_FEATURE]->(f)
MERGE (f)-[:HAS_REQUIREMENT {source: "spec-review", score: 0.9}]->(r)
MATCH (n:Concept) RETURN labels(n) AS chain, n.name AS name

The last line is the payoff of the label chain: one match on Concept returns the journey, the feature and the requirement, each with its full ancestry.

05 · Common traps

Five ways a first graph goes wrong.

01

A retry creates a second copy.

Without stable ids, every replayed import doubles the graph. Cognition OS merges on identity, so a retried request converges instead.

02

The vocabulary sprawls.

If any string can become a type, you end up with Feature, feature and Features. An undeclared node_type or rel_type gets a 400 in Cognition OS, not a new type.

03

A hierarchy loops back on itself.

One bad PARENT_OF turns a tree into a circle and breaks every roll-up. Cycle detection rejects it before insertion.

04

Model output is treated as truth.

Plausible extractions are still drafts. Below the confidence threshold, Cognition OS stages output for review rather than writing it.

05

A fixed similarity threshold is trusted to remove noise.

Kemory’s retrieval notes show why it does not work at scale: nearest-neighbour scores rise as the store grows, so genuine matches and background noise share a band. Read the shape of a result page instead.

06

A many-part fact is squeezed into pairs.

The amount or the date ends up on whichever arrow seemed closest, and the graph misremembers the event. Give the event its own node (step 1).

06 · After you have a graph

Keep it honest. A graph that only grows becomes a landfill.

Cognition OS runs housekeeping agents that keep it coherent: merge / split for nodes that are the same thing or conflate two, link prediction for edges the data implies but nobody stated, hierarchy coherence for parentage that drifted, concept drift for regions that stopped matching their own summary, and quality for naming and structure. Each runs under its own timeout, and because housekeeping mutates the graph, every change is recorded and attributable.

Provenance is the other half. Cognition OS keeps a Graph of Thought: observations, inferences, decisions, questions and answers as a directed acyclic graph, so you can ask any entity what produced it, and creations, merges, splits and links all point back to their cause. Reasoning records the same chain on its side.

On the memory side, Kemory keeps capture separate from consolidation: capture stores discrete items the user confirmed, while consolidate only refreshes a session summary and stores nothing new. Its results say how a search actually ran, and the documentation tells you to read them honestly: an empty result in encrypted mode is not evidence that a memory does not exist. The Kemory panel for Claude Code puts that in front of a person: which memories are in context, with a place to review, rate and save them.

Forgetting is part of the design. Kemory’s memories age through normal decay to an archive, and The Librarian in Your Head (October 2025) sets out the design patterns behind that idea: compress a long history into a summary that keeps its citations, and down-weight a memory that keeps misleading, flagging it for review.

The most transferable habit is publishing what failed. Kemory’s retrieval page lists fixes that were built, measured against a labelled set, and rejected: chunking before embedding (actively harmful), cross-encoder re-rankers (no measurable effect), an asymmetric query prefix (slightly worse) and a fixed similarity floor (inert at scale). The one thing that consistently helped was phrasing queries in the vocabulary the memory was written in.

From SeKondBrain research

  • Put time and certainty in the data model. Concept-Grounded Attention (September 2026) put the concept graph inside a transformer and tested each mechanism against itself switched off. Steering attention with graph structure changed nothing, and concept-graph retrieval recovered multi-hop paths without improving evidence recall. What helped was the memory model underneath: explicit time added 13 to 25 points on LongMemEval across generators up to 122B parameters, and an epistemic status on each claim cut unsupported assertions in 72–122B models from 19–68% to 0–5%. For a graph builder: give facts valid-from dates and a confidence or status before reaching for cleverer retrieval.
  • Measure consolidation, and say where it falls short. Atomic Units of X frames intelligence as organising evidence into reusable atoms. Its tests on three open-source software projects hit the target ratio on two and missed on the third, and the paper reports the miss as plainly as the wins. The research page summarises both.
  • Every claim should beat its own off-switch. Both papers run the same discipline the retrieval notes do: implement, measure against a baseline, publish the negative result.
  • Edges for meaning, distance for strength (research direction). Context Graphs Are the Bridge describes a direction SeKondBrain is exploring: typed edges say what a relationship is, and distance says how strong or relevant it is. Kemory already uses the first half in production: proximity in the memory graph is one of its five re-ranking signals. The geometry half is research, not a Cognition OS or Kemory feature.

Going further: hypergraphs and hyperbolic graphs

Optional, and early. Hypergraph retrieval stores many-part facts as hyperedges: HyperGraphRAG (Luo et al., 2025) and Hyper-RAG (Feng et al., 2025) report gains over standard RAG and GraphRAG on their own benchmarks, not yet independently replicated; the event node in step 1 gets you most of the way today. Hyperbolic embeddings place nodes in curved space where deep hierarchies, such as a label chain, fit with little distortion (Poincaré embeddings, Nickel & Kiela 2017; MuRP, 2019; AttH, Chami et al. 2020). They help link prediction on hierarchy-heavy graphs, mostly at low dimensions. They are research, not a product feature, and you do not need them to build a graph.

Source · Cognition OS housekeeping · Kemory retrieval notes

07 · Recent projects and initiatives

What SeKondBrain is shipping. Newest first.

Public projects and initiatives with their dates, taken from the GitHub organisation, the documentation and sekondbrain.ai, checked 16 Nov 2026. Work that has not been announced publicly is left out on purpose.

NowThe published roadmapRoadmap · As published

As stated on sekondbrain.ai when checked on 16 Nov 2026: Kemory is live in beta; KIT is coming soon, by invitation; SeKondBrain for Business, powered by KompanyBrain, is in alpha and arriving this autumn; SeKondBrain for You is planned for winter 2026 (the home page says winter 2026 or spring 2027).

Public sources
Where it shows up
KemoryCognition OS
NowLabs: Code Graph and friendsLabs · In development

Labs is where tools built for SeKondBrain’s own work are extracted into services. Code Graph, listed as in development, models a codebase as a concept graph: repositories, features and components as connected, queryable structure. RedaKtion, a redaction service that re-checks its own output, is listed as coming soon.

Public sources
Where it shows up
LabsModel
15 NovKemory in every agentOpen source · Shipping

Memory providers that let agents outside SeKondBrain recall before a turn and capture after it. The OpenClaw plugin gained search, store and forget tools on 15 Nov 2026; the Hermes provider documented install, configuration and capture on 11 Nov 2026. Both repositories were created on 21 Oct 2026, Apache-2.0.

Public sources
Where it shows up
15 NovKemory plugin for coding agentsOpen source · v0.17.0

Persistent, cross-session memory for Claude Code and Grok Build: recall under every prompt, a redacted session digest at the end. v0.17.0 shipped on 10 Nov 2026; commits on 13 to 15 Nov 2026 widened secret redaction to more key formats. The companion Kemory panel (v0.20.2, 21 Oct 2026) shows the memories in context and lets you review and rate them.

Public sources
Where it shows up
15 NovPublic platform documentationDocs · Live

docs.sekondbrain.ai is built from a public repository. The Cognition OS, Reasoning, HEVE and Redaktion pillar pages arrived on 3 Aug 2026; a Kemory updates and known-issues page on 21 Oct 2026; a context-compaction benchmark write-up on 20 Oct 2026; the sub-processor list was last updated on 15 Nov 2026.

Public sources
Where it shows up
Cognition OSModelValidate
15 NovDevOps Agent KITOpen source · v2.11.4

A desktop app for coordinating AI coding agents: sessions, worktrees and automatic commits. v2.11.4 shipped on 15 Nov 2026 with fixes to how rebases are resolved and checked. Labs lists a related DevOps Agent, which holds environments and deployments as concepts in the graph, as in beta.

Public sources
Where it shows up
Labs
10 NovKemory CLI and Homebrew tapOpen source · v0.19.1

One command line for connecting MCP clients to a Kemory vault: browser sign-in, an MCP bridge, remember, recall, ask and doctor. v0.19.1 shipped on 10 Nov 2026 in both the CLI repository and the s9n Homebrew tap.

Public sources
Where it shows up
KemoryQuery
2 NovKemory Community EditionOpen source · v0.1.0

A local-first, Apache-2.0 memory server with the same wire protocol as hosted Kemory, so memories stay portable. v0.1.0 was released on 15 Jun 2026; on 2 Nov 2026 it gained automated intake of hosted changes, which are still reviewed before they cross into the Community edition.

Public sources
Where it shows up
KemoryStore
SepResearch programme: concepts, not tokensResearch · Published

Three papers, one argument: knowledge lives at the level of the concept. Cognition as an Ecology (December 2025), Atomic Units of X (arXiv, summer 2026) and Concept-Grounded Attention (September 2026). A white paper on creativity over a concept graph is listed as in draft.

Public sources
Where it shows up
3 AugCognition OS, documentedPlatform · Licensed

The graph your AI reasons over: a multi-tenant property graph with declared ontologies, concept resolution, a confidence-gated ingestion pipeline, housekeeping agents and a Graph of Thought. Licensed and provisioned rather than self-serve; access is requested by email from the docs page.

Public sources
Where it shows up
08 · What to read first

Where to start. Six reads, one at a time.

  1. Cognition OS: data model. Five roots, label chains and relationship families. Ten minutes, and the rest of this page makes sense.
  2. Cognition OS: concepts and resolution. The anchors, neighbours and discoveries cascade.
  3. Cognition OS: ingestion pipeline. Four agents and a confidence gate.
  4. Kemory: retrieval. How the search works, how to phrase a query, and what was tried and rejected.
  5. Kemory Community Edition. The part you can install and run tonight.
  6. Concept-Grounded Attention. What worked, and what did not, when the graph went inside the model.
  7. Context Graphs Are the Bridge (Sachin Dev Duggal). Concept, context and thought graphs, and why distance can carry meaning.
09 · Source library

Every source, typed and linked.

All 36 public sources behind this primer, each tagged with its format, the pipeline step it supports, and its most recent public date. Search, or narrow by step and format.

Step
Format
Nothing matches. Try a broader word, or clear the filters.
10 · Ontology map

The library is itself a graph.

The same ontology as the general primer, applied to SeKondBrain’s public sources. Hover or tap a step to light up its sources and filter the library. Each dot is one source; click it to open the page.

Swipe to explore →

DocumentEach public source is a Document, a kind of Work. 36 in all.
SourceThe site that hosts it, joined by publishedBy. 4 sites.
ConceptA pipeline step or primer theme. A Work mentions the Concept whose section links it.
ConceptSchemeThe construction pipeline: the Concepts as one ordered set (dashed frame).
aboutThe SeKondBrain product or programme a Work documents: Cognition OS, Kemory, Reasoning, Research or Labs.
plain labelsFormat (docs, tutorial, tool, paper) and “next step” are catalogue labels, not ontology terms.

Counts per step add up to more than 36 because a source can support more than one step. Sources cited only from the opening or closing sections sit under Foundations or Keep it honest.