AI agents are geniuses with amnesia.
Every model knows everything about the world and nothing about your company. Mindbase turns the decisions your team already made into an executable, citation-backed brain — so your agents work the way your best people do.
one click into a seeded demo company — synthetic data, real pipeline
- trigger
- A customer reports they stopped receiving webhooks, or they arrive hours late.
- action
- Pause the endpoint, drain the backlog, then replay the missed events.
- verified citation
- incident · INC-13 postmortem
“…the webhook egress certificate expired at 00:14 UTC and customer endpoints stopped accepting deliveries…”
Your company already knows how to do the work. That knowledge just isn’t anywhere an agent can reach it.
It’s in a Slack thread from March. A postmortem nobody reread. The PR review that caught the bug. Four people’s heads. When one of them leaves, it leaves with them — and every AI agent you deploy starts from zero, confidently.
Raw material in. Verified logic out.
The pipeline is the product. Nothing is invented along the way — if a rule can’t be traced to something a person actually wrote, it never ships.
Walk the product, not a promise.
Every frame below is a real screenshot of the running product over the seeded Skysail demo workspace — synthetic company, real pipeline. Scroll through what the brain holds.
Your agent warns you about the outage you already had.
Work near risky ground and your own coding agent surfaces what this company already got wrong there — the incident, the change that got reverted, the review that caught it — each one cited. It is the one thing a general model can never do for you, because it requires your history.
The last time this changed, an expired cert took webhook delivery down for five hours.
“Webhook TLS cert expired, 5h delivery failure — the renewal cron ran outside the VPC.”
- Impact
- webhook egress TLS handshake failing on webhook-gateway
- Root cause
- a recent deploy touched TLS config; matches a known failure class
- Past occurrence◆
- INC-13 (sev1) — “Webhook TLS cert expired, 5h delivery failure”
- Owner◆
- Yuki Tanaka — top committer on webhook-gateway
- Runbook◆
- Webhook delivery-failure runbook (approved)
It watches. An alert fires; the diagnosis is already written.
A brain wakes up when something happens. A signal arrives and the Sentinel investigates on its own — which service, what deployed, has this happened before, is there a runbook, who owns it — and emits a cited card before a human opens a laptop. Observability tools reason from the machine’s telemetry; the three ◆ fields need your organisation’s memory, which is why only this can produce them.
With a human’s approval it goes further: a sandboxed agent reproduces the failure, writes a patch, runs the tests, and opens a reviewable PR — it never pushes to your main branch, and never claims a fix it didn’t make.
Why a technical team would trust it.
- Provenance you can click
- Every rule traces to the exact Slack thread or postmortem it came from. No verified citation, no rule — that's enforced in code, not promised in a policy.
- Human-approved, fully audited
- The brain drafts; a person approves; every action is logged against who signed it off. Autonomy is earned per skill, on a track record — never assumed.
- The private Neuron
- A Mac app keeps each person's AI-session insights on-device (Claude Code capture; Cursor honestly labelled pending, in-app too). Nothing leaves the machine until they choose to promote it — and the sync payload structurally cannot carry a transcript.
- Autopilot
- Give it a goal. It plans from your real runbooks, drafts the parts an agent can safely draft, and routes what belongs to a person straight to that person.
- It learns how you work
- Your rhythm, the gotchas that have bitten you before — so your agent carries your context, not a generic one. Self-facing by design: it's your view of yourself, never a manager's dashboard.
The Neuron. Your half of the brain, on your Mac.
A native menu-bar app where your AI-session insights live on-device, visible only to you — Claude Code capture, with Cursor honestly labelled pending in the app itself. Everything lands private. You decide, per insight: keep it, share a summary, or promote it to the company brain — and the sync payload structurally cannot carry a transcript.
macOS 12+ · buildable today from this repo in one command — npm run build:mac— see BUILD_MACOS.md. Explores 12 seeded sample sessions out of the box, labelled “demo data”; capturing your own sessions is flag-gated in this build, and live sync needs a paired Mindbase backend. Or try the hosted demo instead.
the real app — native window screenshots of the built .dmg, seeded demo data
Built for engineering-led companies putting AI agents into production — where an agent that doesn’t know your rules costs you an incident, not a typo.
The people who feel it first: the CTO betting on agents, the VP of Engineering who owns the on-call rota, and the Head of Ops who wrote the runbook everyone forgets to read.
What’s real, and what’s honestly next.
This is a portfolio demonstration on synthetic data. The distinction below is the point — the product’s credibility is that it has never once lied about what’s real.
- The full pipeline: ingestion → extraction with verbatim-verified citations
- Human review, the autonomy ladder, and a full audit trail
- A System Brain of services, dependencies and deploys — derived, never invented
- The Sentinel: signal → cited diagnosis (Impact / cause / past incident / owner / runbook)
- A sandboxed remediation agent that reproduces, patches, tests and proposes a PR
- MCP serving, and a native macOS Neuron with a structurally-private layer
- OAuth connectors to live Slack / GitHub (the ingestion interface is source-agnostic and ready)
- Container / microVM sandbox isolation (today: real macOS Seatbelt confinement)
- Live model reasoning without a key (today: an honest deterministic path, labelled)
- Verified against live Sentry / uptime accounts (adapters implemented to their documented formats)
Give your agents your company’s memory.
Sign in and walk it end to end: connect a source, watch the brain build from real evidence, and point your own AI tools at it.
Under the hood. Real extraction over your own artifacts — every element of every rule is verified verbatim against its source before it ships, and anything unverifiable is dropped rather than guessed. Served over the Model Context Protocol, so any MCP client already works. Provenance-first: a rule without a citation doesn’t exist. The brain advises and drafts; it never executes.