Galileo connects the Sources your team already uses and builds a knowledge graph over them. It surfaces Findings — stale docs, conflicting claims, and doc↔code drift — each backed by Evidence you can trace to its Source, dismiss claim by claim, and resolve through a lifecycle that verifies every fix.
Free tier — 2 Sources, unlimited seats, no card required.
Connects the Sources your team already uses
GitHub and Notion today — more on the way.
Your team pieces together wikis, READMEs, and tribal knowledge — and nobody can say which page still matches the code. The doubt is silent: a page keeps looking authoritative long after it stops being true.
Coding agents and new hires read documentation as ground truth. A stale page doesn't slow them down — it confidently steers them wrong, and the mistake surfaces in code review, or in production.
It builds an Evidence-backed knowledge graph over your Sources and surfaces grounded Findings for stale, contradictory, or code-drifting documentation. Deterministic rules detect staleness and judge Conflict and Drift proposals, while coverage stays visible when Analysis is partial.
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.
Galileo builds a knowledge graph over your Sources and flags where your documentation no longer matches the code. Every flag is grounded in Evidence, not a model guess.
Authorize GitHub or Notion as an Org Connection, then choose the repos and pages to sync. Credentials are encrypted at rest, pull Sources store only their scope, and you can organize Sources with Labels and Access policies.
Galileo maps how your system actually connects — documents, code changes, people, and symbols. Every node and edge traces back to the exact Source and location it came from, and cross-source edges are validated before they enter the graph.
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. You can dismiss individual claims, not just the whole Finding.
Create work items from a Finding, link them to GitHub issues or Notion comments, snooze low-priority items, and deep-link straight to the Evidence that triggered the flag.
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.
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.
Galileo is built Org-first: everything it ingests, builds, and flags stays scoped to your Org, with explicit controls over provider access and AI processing.
Every Source, Node, and piece of Evidence is scoped to your Org, so every read and write remains Org-scoped.
Connection OAuth material and webhook signing secrets are encrypted at rest. Pull Sources never store provider tokens.
Conflict and Drift proposal and verification calls use a pinned zero-data-retention route that denies provider data collection.
Galileo reads only the repos and pages you authorize, and you can revoke that access at the provider at any time.
Access policies filter search and Finding details per member. Write-back is off by default and automatically disables when a provider rejects the required permission.
Org data export and GDPR-grade user export and deletion are built in — leaving is a feature, not a ticket.
Galileo is not another AI that hallucinates a report. It combines deterministic rules with grounded, Evidence-backed proposals so every Finding is traceable and resolvable.
Invite your whole team for free — seats are unlimited on every plan. You pay for the Sources you connect. Start on the free 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. Conflict and Drift proposal and verification calls use a pinned zero-data-retention route that denies provider data collection. No claim is surfaced without its Evidence trail.
Every Source, Node, and piece of Evidence is scoped to your Org, so every read and write remains Org-scoped. Connection OAuth material and webhook signing secrets are encrypted at rest (Cloak); pull Sources do not store provider tokens.
Yes, through work items. From any Finding, managers can create a linked GitHub issue or Notion comment, transition it as the Finding resolves, and deep-link back to the Evidence. Enablement is controlled per Source and fails closed if the provider permission is missing.
You're billed per Org by the number of Sources you connect, with unlimited seats on every plan. The free 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.
