An events driven platform ingesting organizational activity into a knowledge graph for intelligent agentic outcomes.
onBrain
See it liveHOW onBrain WORKS
onBrain turns real-time activity across your organization's third-party applications into a living knowledge graph. This graph becomes the context that grounds how agents plan, decide, and act. Humans can also query company knowledge to understand past activity, tools that have been built, and how decisions were made; all while maintaining proper access control.
01 · INGEST
Event hooks into workplace tools such as Slack, GitHub, Jira, and more feed into one ingestion pipeline. Messages, PRs, tickets, and employee changes arrive as normalized, disambiguated events with a consistent format. Identities of those involved are resolved across platforms.
02 · GRAPH + ANALYZERS
onBrain extracts meaningful labels, connections, and metadata from events which are written to a graph database. Dozens of analyzers sit on top of the graph to produce meaningful insights, hands free as events flow in.
03 · FINDINGS + ACTION
As findings flow in, action proposals are made. Personalized configurations dictate whether issues require approval or can initiate auto-implementation of solutions to remediate problematic findings.
Route TASK-84 from Backlog to Ingest / P1 with owner @sam.
How the graph reasons
A raw event becomes a typed, evidenced finding through one pipeline. Analyzers can only cite concrete identifiers pulled from the graph — issue keys, repos, people. If a claim can't be grounded back to observable facts, the runtime drops it. No phantom findings.
Ingest
Normalize events
Extract
Entities + links
Graph
Written with valid_at
Analyze
Reason over event
Act
Proposed under approval
Actual analyzer output
// scenario D3 — Identity + Compliance { "analyzer": "DuplicateWorkAnalyzer", "severity": "high", "description": "kyc-compliance and kyc-service are building independent OFAC screening + identity scoring.", "action": "Coordinate before expanding scope", "evidence": ["org/kyc-service", "org/kyc-compliance", "SEC-2201", "INFRA-4821"], "confidence": 0.92 }
Typed & severity-scored
Findings are structured objects, not prose — routable, filterable, and machine-actionable.
Evidence you can click
Every finding names the exact repos, tickets, and people it was derived from.
Grounded or dropped
Claims that can't be tied to graph context never reach you. Precision over volume.
Product
Every fact carries a valid_at timestamp. Nothing is destructively edited — ask what the org looked like on any date.
Claude Desktop, Cursor, or any LLM agent queries the graph and invokes skills over MCP — no bespoke integration code.
Automated entity resolution for disparate 3rd party accounts ensuring a consistent, unified identity - so ownership questions just work.
Findings must cite real repos, tickets, and people — or they're dropped.
Vector search + keyword matching + graph traversal. Every finding cites concrete identifiers from the graph or it never fires.
Automated action fires on pre-approved scopes while remaining actions wait behind human approval gates - fully logged and traceable
Answers respect each person's permissions.
Identity-aware permissions control what someone should or shouldn't see to expose as much context as possible without compromising security.
See it live
An agent sees the gap, drafts the action, a human approves, and it ships — then the graph updates itself. This is the whole loop, end to end, with a human in the middle of every mutation.
Sofia Reyes #platform-arch
Let's write a jira ticket for the auth-service rewrite. Neil can take this.
Create AUTH-412— “Auth-service rewrite”, assign @neil, label auth-service, link back to the Slack thread.
Jira
waiting…
Knowledge graph
waiting…
Timeline
Slack message arrives in #platform-arch
Fast-path analyzer detects the trigger phrase
Searches existing Jira — no matching ticket
Approval card appears with a human-readable preview
Human clicks Approve on a single-use token
Ticket filed — assigned, labeled, linked to the thread
Graph hydrates the new node; next query returns it
Surface → Remediate
A fleet of analyzers reads every event and surfaces what matters — read-only, always-on. A focused set of skills then remediates, and every mutation waits behind a human approval gate.
Read-only · always-on
The downstream services and teams a change actually touches.
Missing reviews, recent incidents, and high-churn hot spots.
PII / HIPAA / SOC2 paths changed without the required review.
Issues and PRs open far past the team's own norm.
Someone already solving the same or an adjacent problem.
Defects and meeting commitments with no owner in the graph.
Docs contradicted by recent PRs, deploys, and schema changes.
Overloaded owners while relevant experts sit underused.
Missing required plans, suggested design revisions, and cross-team coordination recommendations.
Mutating · human-approved
Intelligently routes follow-up actions and untracked work as tickets.
Reads a linked issue, retrieves context, writes code, and opens a PR to review.
Pings the owner of a stalled ticket or PR with a graph-derived reason it stalled.
Opens a thread between teams when duplicate work is planned or timeline coordination is required.
Routes to on-call by graph-derived severity — pages only on confirm.
Builds a role-tailored ramp plan from graph-derived owners, systems, and prior decisions.
Prompts a departing employee to document the systems and decisions they hold while also notifying past and current teammates of their exit.
Validated end-to-end
~600
events ingested
PRs, tickets, messages, deploys
28
repos across 8 teams
in the synthetic org
311
findings
duplicate work, stale work, routing
220
identities resolved
across GitHub, Slack, Jira & HRIS
Measured in demo mode against public fixtures — customer numbers land with our first design partners. Every scenario asserts the expected finding, so the pipeline is regression-tested, not hand-picked.
onBrain ships as proprietary software you run in your own VPC. Your data stays in your infrastructure. Entity extraction calls the LLM provider you configure; nothing is routed through us.
onBrain is identity-aware — every answer respects the asker's permissions. Someone only sees knowledge derived from sources they're already entitled to, so sensitive channels, repos, and HR data stay scoped to the right people.
Retrieval is grounded in the graph — vector search, keyword matching, and graph traversal combined. Every finding requires citations to be present — real repos, PRs, tickets, people — or it's dropped. You receive answers with evidence you can click through, not a plausible guess.
Yes — but only when you configure it to. By default, mutating actions are approval-gated: the agent proposes, a human approves. You can grant an agent autonomy for specific actions or scopes, then tighten or revoke that authority at any time — down to the individual skill.
The set of integrated tools is constantly evolving and onBrain can work toward connecting the integrations you need if they aren't yet supported. Reach out if you'd like a complete list of what's connected at any given moment.
onBrain backfills from your existing history on connect — pulling in past pull requests, tickets, and org data — so the graph starts populated with real context instead of empty and slowly learning.
The everyday user will most likely interface through our frontend dashboard, which supports question answering, graph viewing and traversal, agentic findings, and more. No technical skill is required.
onBrain ships an MCP server so any LLM agent can query the graph and call skills today with no bespoke glue code.
Every fact carries a valid_at timestamp and is never destructively edited — only superseded. That means you can replay the org's state at any point in time ("who owned auth-service in January?") and get a grounded, deterministic answer instead of whatever the current snapshot happens to say.
Where we're going
Everything below is roadmap, not shipped. If you'd like to influence what comes next, get in touch.
The roadmap is shaped by the first three design partners.
Investors
We're raising our pre-seed to bring on design partners, harden the platform for production deployment, and kick off our go-to-market.
Why now
Agents are here — but they can't act intelligently without proper company context. Giving them that context is the next phase of how large businesses operate.
Validated direction
The thesis is proven, and the industry is visibly converging on company brains as the layer agents run on.
Why us
We have the engineering expertise to build it — and a working proof of concept that proves it. Capital lets us productionize, QA, and keep pace as the space accelerates.
We're building onBrain with our first design partners. If the org-memory problem is yours, we'd like to hear from you directly.
Neil
Technical founder and ML Engineer with 10+ years building scalable AI software at Apple and Accenture.
Prateek
Technical founder. Leads retail and finance applications at Apple. PhD in Electrical and Computer Engineering.