Your agent knows what it knows.
And where it knows it from.
factgraph is the knowledge memory for AI agents: facts with source and time window, contradictions visible instead of silently overwritten, every answer reproducible — no language model in the core.
23 tools · dedicated server in the EU · TLS at the edge (Cloudflare)
Your agent doesn't just remember. It knows what was true when.
Agents rarely fail on the model — they fail on their memory.
Plain agent memory
“CockroachDB.”
PostgreSQL was overwritten, the reason lost, the source gone.
With factgraph
Current: CockroachDB.
Before that PostgreSQL; migration in March.
Reason: connection pool limit under load.
Source: architecture decision, 14 March. · The old statement stays in history.
That is exactly what factgraph is for. — example data
What it looks like
Four views of an example knowledge base (synthetic, abridged). Measured numbers: Benchmarks.
Search: “Why did checkout get slower?”
Fusion of lexical + semantic + graph: every hit with provenance. The ranking is deterministic — same question, same corpus state, same order.
Forecast from connection-pool — path with evidence:
— causes (+1 · 0.7) → checkout-latency
Expectation: latency stays elevated as long as the pool limit is not adjusted. (window 7 days, min strength 0.5)
Evidence: 2 edges, each with agent and source. Determinism: same input ⇒ same result, no language model in the path.
History: checkout-latency (one statement, two states)
Oct 14 superseded — strength 0.5 (changed: strength; the old version is kept)
Every state stays retrievable via time travel: “What was true on Oct 13?” is an answerable question — nothing is silently overwritten.
Conflict: two agents, two statements — both stay
✗ “OOM under peak load” — agent B · Oct 14 · source: incident report
Conflict marked, not resolved. Both pieces of evidence stay visible with provenance; the namespace policy only defines how they are shown (all states or “latest-wins”) — your agent decides.
What is different
Time is explicit
Two axes: what was true and what we knew — with citable states.
Contradictions stay visible
Nothing is silently overwritten: both sides with source, your agent decides.
Deterministic
Same question, same corpus state ⇒ same answer. No external model APIs: embeddings run locally on our own CPU.
One knowledge core
Namespaces and scopes instead of five separate memories — one system of record for all agents.
Why this matters: The four context pitfalls — and what the engine does about them. Numbers: Benchmarks.
How it works
1 · Connect
Your agent connects via MCP endpoint and token — no SDK, no build. The engine ships its own playbook.
2 · Learn — your agent extracts
It stores facts it has learned: cause, dependency, decision. It is the extraction layer — factgraph is no autopilot: documents never become facts automatically. In return: no extraction cost per turn and no model errors in your knowledge base.
3 · Use
The engine computes: search, history, forecasts along cause-effect chains — every statement with provenance, every inference traceable.
Your language model for creation, factgraph for your hard data. Business-critical facts must not be a statistical experiment.
First voices will follow.
The beta is just starting — real user feedback will appear here soon. We do not quote our own agents as customer testimonials.
The engine does not understand time — it computes with time. What exists as a fact with a time window and a relation becomes computable; language and world knowledge stay with the model. In between sits your agent: it understands — the engine supplies the evidence.
Team chat hub. The same memory for humans: Mattermost at hub.factgraph.sh · What the hub does
Running in 60 seconds
No SDK, no LLM, no build. Three ways: your agent speaks MCP, your chat UI takes a prompt — or you take a first look with curl.
1 · Connect an agent (MCP)
{
"mcpServers": {
"factgraph": {
"url": "https://factgraph.sh/mcp",
"headers": { "Authorization": "Bearer ctx_…" }
}
}
}
One token with write scope for a namespace — done. From there, 23 tools are available: search, push facts with time windows, history, structure, activity.
2 · Take a look first (curl)
curl -s https://factgraph.sh/healthz
# → {"status":"ok","version":"0.6.1"}
curl -s -H "Authorization: Bearer ctx_…" \
-H "User-Agent: my-agent/1.0" \
https://factgraph.sh/v1/changelog
User-Agent is mandatory — without it the edge returns 403. The most common first surprise.
3 · Chat agents via prompt (Hermes, Slack, custom)
Chat UIs don't read a config file — here the onboarding is a prompt to your agent. It stays tiny because the engine brings its own manual: initialize returns the instructions automatically, ctx_guide the personal playbook.
From now on you have access to the Context-Engine (factgraph.sh) — our
deterministic knowledge repository (no LLM in the core, everything auditable).
CONNECTION:
- Endpoint: https://factgraph.sh/mcp · Authorization: Bearer <YOUR_TOKEN>
- Methods: initialize, tools/list, tools/call
FIRST STEP OF EVERY SESSION:
1. initialize — the response carries your instructions automatically.
2. ctx_guide WITHOUT a topic — your playbook (who you are, your namespaces,
all workflows, error recovery). FOLLOW ITS INSTRUCTIONS.
CORE RULES:
- YOU ARE THE EXTRACTION LAYER: learned a new cause, dependency or decision?
ctx_push_facts. Documents (ctx_upload/ctx_ingest) NEVER become facts by
themselves.
- Before ctx_push_facts ALWAYS ctx_resolve: canonical entity ID, no
near-duplicates.
- Learned cause and effect? Store it as a fact (sign/strength/lag) —
ctx_infer turns it into deterministic predictions.
- 422: the message names every accepted value → fix it, push again.
- 502/503: wait 2-3s, retry ONCE (deploy window).
Minimal prompt, the engine carries its own manual — new tools and workflows flow in via the playbook, no prompt drift. Hand the token over via DM/secret, never post it in a channel.
4 · Team chat hub at hub.factgraph.sh
Mattermost as a chat entrance to your namespace: beta users are enabled per person and query their own knowledge right in the chat — answers come evidenced from the engine (search, timeline, new facts via /ctx remember), no LLM in the core. The hub is a client: it sees exactly the namespaces your agent has read access to.
/ctx search kafka duplicate-consumption search your namespaces
/ctx timeline kafka-cluster history + versions of a topic
/ctx remember a | core:causes | b store a fact
/ctx whoami agent, rights, hub access
The team chat runs (invite-only) next to the API; access and revocation are anchored on the agent — revoked is revoked, instantly.
The core loop in six steps
A fact with valid_from tomorrow: announced, not yet valid. Search does not show it, history does — and after retracting, it stays in history, with timestamps.
[1] engine up? version=0.8.1 status=ok
[2] deploy log latest: v0.8.1 (2026-11-11)
[3] namespace health version: 0.8.1
[4] push ANNOUNCED fact (valid_from=2026-10-25)
Facts accepted: 1. Graph views update shortly (async).
[5] search (graph:true): fact hit = False ← announced facts stay out
Timeline …:quickstart-demo-fact: 2 entries (current 0, upcoming 1, historical 1)
[6] retract
1 fact(s) retracted … History stays queryable via as_of_valid (bitemporal).
Timeline …: 2 entries (current 0, upcoming 1, historical 1) ← stays, by design
ALL GREEN — 6 steps, zero LLM, namespace left clean.
60 lines, standard library only: curl -O https://factgraph.sh/quickstart.py — actually run, not rendered.
Where people get stuck the first time
- User-Agent is mandatory — otherwise 403 from the edge.
- Unknown fields and unknown tool arguments are rejected; the error names the accepted ones. The API documents itself.
- Entities are addressed as
namespace:id; the depth parameter isdepth, notmax_depth. - Announced facts are invisible in search and neighbourhood, visible in history (
upcoming) — opt in elsewhere viamodes.graph.include_upcoming. - Retracting is bitemporal: it sets the end, it never deletes. History stays queryable.
- Graph views are asynchronous — wait a moment after pushing.
Your agents.
In the chat everyone knows.
Mattermost at hub.factgraph.sh is the chat door to your knowledge:
one account per person, one personal agent each — and every answer comes with evidence
from your knowledge engine. No LLM in the core, no black box: sources, timestamps and open
contradictions are part of the answer.
👤 One account, one agent
Each person gets an account and a personal agent. An agent can explicitly be shared with others — ownership and usage stay separate.
📎 Evidence, not claims
Every statement names its source and timestamp. Contradictions are not smoothed over but surfaced — with both records.
🧵 History & prediction
How did a topic evolve, what follows from it? The history stays queryable, including as of a past date.
🎨 Agents with a face
Profile pictures for people and agents, so the chat shows who is answering. Images stay with you — nothing goes to third parties.
Getting into the hub
The beta is enabled per person: we set you and your agents up and create the channels.
Your data — short, no small print
What is stored
- For beta access: e-mail and the namespace name you pick.
- What your agent pushes: facts, documents and edges — with their time information.
- For operation: access logs (which agent did what, when) and runtime metrics.
What does not happen
- No training on your data. No sharing with third parties for ads or analytics.
- No language model in the core — your content never reaches a model provider.
- No ad trackers, no cookies on this page.
- No silent overwriting: retracting sets an end, it does not delete.
What you control
- Access only with your token, limited to your namespace.
- The token is shown exactly once and stored hashed.
- Deletion: retract facts yourself; documents and nodes you delete stay recoverable for 30 days.
- No lock-in: export your complete knowledge base (entities, facts, sources) at any time.
- Details (German): privacy notice · imprint.
Infrastructure: a dedicated server in the EU; TLS is terminated at the edge (Cloudflare), the origin sits behind the tunnel — no open ports 80/443. Operated by Seifert Software Solutions, Hamburg.
Give your agent a memory you can trust.
Creates your agent + your own namespace. The token is shown exactly once.
Loading seats …
Rather try it first? Test in 60 seconds (curl). The beta is free; pricing arrives at general availability — beta participants will hear about it first.