Galileo connects the Sources your team already uses and builds a knowledge graph over them. Then it surfaces Findings — stale docs, conflicting claims, and doc↔code drift — each backed by Evidence you can trace to its Source.
Connects the Sources your team already uses
GitHub and Notion today — more on the way.
Galileo builds a knowledge graph over your Sources and flags where your documentation no longer matches the code.
Authorize GitHub or Notion as an Org Connection, then choose the repos and pages to sync. Credentials are encrypted at rest, and Sources store only their scope. GitHub and Notion today, with more on the way.
Galileo maps how your system actually connects — the artifacts your team ships and the concepts they describe. Every node and edge traces back to the exact Source and location it came from, so nothing in the graph is unsourced.
Galileo opens a Finding when a document falls behind — by Evidence timestamps, or when it names a code symbol that no longer exists — and tracks it from open to resolved so every fix is verified against the Evidence.
When two Sources describe the same thing in conflicting terms, or a doc claims something the code doesn't do, Galileo opens a Finding with both sides' Evidence side by side.
Knowledge that lives only in people's heads and chat threads, surfaced as Findings before the person who holds it moves on.
An org-scoped MCP server that serves your graph to coding agents with freshness attached, so they read each doc alongside its Findings instead of assuming it's still current.
Connect a Source, let Galileo build the graph, and review the Findings it surfaces.
Authorize GitHub and Notion under Connections, create a Source with the repo or page scope you want, and the first Sync starts right away.
Artifacts and Concepts land in an org-scoped knowledge graph, each one carrying Evidence back to the exact Source location it came from.
Galileo opens Findings — stale documentation, cross-source conflicting claims, and doc↔code drift — with a full lifecycle, so every fix you make is verified against the Evidence trail.
We're in beta — these are illustrative scenarios, not real customers yet. They show the stale-documentation, conflicting-claims, and doc↔code drift Findings Galileo surfaces today.
An 80-engineer scale-up connects GitHub and Notion. The first cross-source Sync opens Findings on a third of their architecture pages — docs whose Evidence timestamps lag the code Activity that still describes those services. The team fixes the worst offenders and resolves each Finding against its Evidence.
A Notion page and the GitHub README describe the same service in contradictory terms — the page says auth is token-based, the README says it's session-based. Galileo opens a Finding on that service with both Evidence trails side by side. The team reconciles the two, and the Finding resolves.
A runbook claims an auth helper returns API keys. The linked code symbol returns sessions instead. Galileo opens a doc↔code drift Finding with the claim quote and the code Evidence side by side — the team updates the runbook, and the Finding resolves when the re-check passes.
Invite your whole team for free — seats are unlimited on every plan. You pay for the Sources you connect. Start on the free beta tier with 2 Sources, no card required.
Keep your team's documentation honest.
$99.00 / month
Get started$82.50 / month (paid yearly)
Get startedKnowledge health across the whole org.
$499.00 / month
Get started$415.83 / month (paid yearly)
Get startedThe things engineering teams ask before they connect their first Source.
GitHub and Notion today. A scoped GitHub repo Syncs the README and every in-scope `.md`/`.mdx` as documents with content blocks, recent commits as code-change and person nodes, a complete ignore-aware Trees API file manifest, and — after Sync — public code symbols for Elixir, Python, JavaScript/TypeScript, and PHP. Scoped Notion pages become documents with complete block capture. Linear and more are on the roadmap — the graph is built to absorb them.
Deterministically. The stale-documentation detector runs set-based rules over Evidence timestamps and over doc→symbol links when a named function no longer exists — no model guesses whether a page is out of date.
No. An LLM proposes structure the timestamps can't see — that a Notion page describes a given GitHub service, that two Sources contradict each other, or that a doc claim disagrees with linked code — but every proposal is grounded in verbatim Evidence, and deterministic rules alone open, sustain, and resolve Findings. No claim is surfaced without its Evidence trail.
Every Source, node, and piece of Evidence is scoped to your Org — there is no way to reach data outside your tenant. Connection OAuth material and webhook signing secrets are encrypted at rest (Cloak); pull Sources do not store provider tokens.
You're billed per Org by the number of Sources you connect, with unlimited seats on every plan. The free beta tier includes 2 Sources; Team and Scale raise the limit as your graph grows.
Connect your first Source and see what your documentation isn't telling you.
