Onboard

The Context Layer
for Software

Code is executable.

Context is invisible.

Until now.

Add a Repository See It in Action

Software Has a Blind Spot

Every serious repository contains years of:

Architectural rewrites that never made it into docs
Migration decisions buried in PR arguments
Performance fixes hidden in commit diffs
Directories everyone avoids but nobody labels
Social ownership patterns that determine what is safe to touch

This is institutional memory.

It lives in git history, review threads, and team folklore.

It disappears when people leave.

It never reaches AI.

Introducing
Repository Context Infrastructure

Not documentation.

Not search.

Not embeddings.

A structural layer that exposes institutional memory to humans and machines.

Ingest the Full Story

Complete git history
Pull requests with review discussion
Issues and decision threads
Code structure and dependency graph
File churn and modification frequency
Ownership and contributor patterns
TODO and FIXME surfaces

Every signal that reflects how the repository actually evolved.

Extract Architectural Memory

Onboard identifies:

Inflection points and rewrites
High-risk and high-change regions
Migration timelines
Core abstraction boundaries
Dependency fault lines
Long-running technical debt
Social ownership clusters

Not summaries.

Structural intelligence.

Generate Context for the Reader

Context is not one-size-fits-all.

Onboard produces tailored views:

New Engineer

What to read first
What not to modify
Where migrations are active
Which modules are stable

Staff Engineer

Rewrite history
Architectural fault lines
Long-term risk surfaces
Subsystem cohesion and churn

Security or Compliance

Auth boundaries
Sensitive modules
High-risk dependency injection paths
Access control logic clusters

Built for Agents

AI coding agents can read files. They cannot infer history.

Onboard delivers structured repository context as machine-readable intelligence.

context.json

{
  "high_risk_directories": ["auth/legacy", "scheduler/core"],
  "hotspots": ["migration_framework", "reconciler"],
  "architectural_inflection_points": [
    {
      "area": "auth",
      "reason": "token migration",
      "introduced_in": "PR#18421"
    }
  ],
  "ownership_clusters": [
    { "team": "core", "files": 142 }
  ]
}

Not just files. Not just embeddings. Context.

The Missing Layer
of Modern Software

Databases store data.

CI systems ship code.

Version control tracks change.

Nothing exposes repository context as infrastructure.

Until now.

Built for a World Where
AI Is a Contributor

In the next decade:

AI will open pull requests
AI will refactor subsystems
AI will migrate frameworks
AI will modify production logic

Without context, those changes are blind.

With context, they are informed.

Distribution

Web App

Instant repository intelligence.

CLI

Generate persona-aware context locally.

onboard generate --persona staff-engineer

MCP Server

Serve structured repository context to Claude Code and compatible agents.

API

Embed repository context directly into internal tooling, CI, and autonomous systems.

Why This Matters

Institutional memory is the most fragile asset in software.

When engineers leave, context decays.

When AI writes code, context is ignored.

When migrations happen, intent disappears.

Onboard makes context durable.

Queryable. Structured. Transferable.

Make Context First-Class

Turn your repository
into a context layer.

Add a Repository

The Context Layerfor Software