The intelligence layer for autonomous engineering.
Rafinery captures the thinking behind your code and turns every decision, correction, and change into compounding engineering knowledge. Agents use that knowledge to move from ticket to deployment with less human intervention — getting better with every task they complete.
- Started
- 5 July 2026
- Team
- Founder + 3–4 to hire
- Status
- Not yet incorporated
- Round
- Open — terms on request
- Site
- dev.rafinery.ai
- Contact
- gallirohik@gmail.com
Problem
Most of what makes an engineer effective isn't in the code.
It's knowing why something was built a certain way, what went wrong before, which approaches didn't work, and all the small conventions and decisions experienced engineers carry with them. Coding agents write code incredibly quickly, but they come into a codebase without that history. They rediscover things the team already knows, forget corrections, and repeat mistakes engineers have already solved.
Starts from zero
The agent re-reads your repo from scratch on every task, for ever. That's the biggest single source of token waste in the loop.
Is lost with the session
You fix the agent at 11pm. Tomorrow it makes the same mistake, because nothing saved what you told it.
Turns into detective work
Teams now produce three times the diff with exactly as many senior reviewers as before.
apps/web/components/marketing/_data/content.ts → QUESTIONSMeasured
We use Rafinery to build Rafinery. In one A/B experiment, the same feature used 51% fewer tokens with the graph, and the agent avoided a correction round caused by an engineering convention it didn't know about. Same model, same task, separate working copies. Both shipped working code, but the cold agent spent more fixing its mistake than its entire build.
The caveats, published rather than buried: this was a 20-file repo, close to the worst case for this idea, since reading a small repo cold is cheap. And the advantage was following conventions, not raw build speed. It gets bigger with the codebase, not smaller.
examples/sample-brain/audits/2026-06-03-brain-vs-cold-execution.md published in full at dev.rafinery.ai/measured. Run 3 June 2026, a month before this repository's first commit. This result is why the company exists.The compounding
Each task makes the next one cheaper.
That was one task. The product is what happens to the thousandth. The halved token bill is the benefit we could put a number on. The same graph feeds everything else in the system, and none of it costs a second run.
The TODO from eleven months ago ships with today's ticket
Before a line is written, the most useful open improvements near this change are offered as optional tasks. Debt gets paid by work that was happening anyway.
No refactor sprint to schedule. Nothing to remember.
The CVE you'd only find by running a security audit
Every merge re-checks the dependency tree against the live advisory database. Critical findings surface even outside the change, and the graph says whether the vulnerable path is actually reachable in this codebase.
Freshness depends on how often you merge, not on someone booking an audit.
Queryable the moment it merges
No re-index window, no nightly job, no “the wiki will catch up.” The merge updates the graph and re-checks what it touched, so the next agent, seconds later, already knows what changed and why.
Every other knowledge product has a staleness window. Ours is the merge.
The bug report answers itself
A user question or a bug lands. An agent checks it against the graph: which flow it ends in, which constraint it breaks, which decision put it there. It cites the line and proposes the fix before anyone is paged.
The on-call engineer arrives to a diagnosis, not a mystery.
Nobody's first month is spent interrupting whoever remembers
A new engineer, or a brand-new agent session, asks why the code is the way it is and gets the decision, the rejected alternatives and the incident behind the constraint. With the evidence.
The same answer, at the same confidence, for everyone who asks.
Every merge feeds the graph. Every surface spends it.
One scan starts it. Every commit after that improves it. Debt goes down, the vulnerability window shrinks, answers get cheaper, all paid for by tokens already being spent on shipping features.
The system knows more at your next change than it did at the last one.
apps/web/components/marketing/_data/content.ts → COMPOUNDING .claude/skills/rafa-security/ modeled the first-responder agent is specced and partly built, not yet shipped.Product
One command. Then every agent in your stack gets smarter.
npx @rafinery/cli initCode, git history, PRs, incidents, your corrections
Turned into small, linked notes with the evidence attached: rules, playbooks, decisions, contracts, flows.
Queries, not searches
Ask with conditions, follow links, ask what's absent, ask about a point in time. Text matching is one condition among many. “We deliberately don't do that here” is a real answer.
Every link carries its evidence level
Verified against code · written by a person · derived. An answer is only as confident as the weakest link on its path.
Every merge re-checks what it touched
Stale knowledge is caught by the pipeline, not by an incident. Nothing depends on anyone remembering to write something down.
The factory
Code and history in. Knowledge out, to every agent you run.
Autonomous engineering doesn't fail at writing code. It fails at shared, trustworthy context. A fleet of agents with no shared memory is a fleet of confident guesses that contradict each other.
- Works with any agent. MCP is the connection. Claude Code, Cursor, Codex, CI bots and whatever a company builds in-house all read the same graph. We never have to pick the winner.
- Usage grows without a new sale. Every agent an org adds is another reader of the graph they already pay for. Fleets grow; the graph underneath isn't bought again.
- The five agents are included. The graph works with any others. Our five agents install with the graph and run development for the customer. Swap any of them for Cursor, Claude Code, Codex or an in-house agent and the graph serves it the same way.
.arohi/2026-07-29-knowledge-graph-spec.md §6 every consumer follows one tool-neutral 7-step contract and specialises exactly two steps.How it works
A ticket becomes a shipped change, with exactly two human gates.
The five agents come with the graph and run this loop on the customer's repositories. We run Rafinery's own development the same way. Any agent they already use reads the same graph alongside them. The agents are included; nothing requires them.
- A card moves on the board. Our intake agent replies with the rules and past decisions that already apply to that area.
- The plan starts informed. What the change touches is computed from the graph. Known debt in that area is offered alongside; dismissible, never blocking.
- Human gate 1: approve. No agent can skip it.
- The build goes straight to the right lines. Then Prism, working in isolation, re-runs every check itself and judges the code, not Atlas's description of it.
- Human gate 2: merge. Everything after runs on its own: the merge updates the graph, retires what's obsolete, re-audits dependencies.
- The team finds out, with the evidence. Slack answers what shipped, why, and what it touched, citing the same line the card started from.
Every merge feeds the graph. Every surface spends it.
One scan starts it. Every commit after that improves it. The system knows more at your next change than it did at the last one.
Automate the chores. Never the judgement.
The graph is made of human reasoning: decisions, rejected alternatives, hard-won lessons. None of it was generated by a model. Our only job is to stop it being lost.
apps/web/components/marketing/_data/content.ts → STAGES .arohi/factory.mdWhy now
Agents can write the code. Trust is what holds autonomy back.
Autocomplete
Agents suggested lines. The context was one file. A human read every line.
Agents ship diffs
The context became the whole repo, re-read from scratch on every task by every agent.
MCP standardises the connection
Any agent can read outside knowledge through one protocol. A knowledge layer becomes possible to build, portable, and worth owning.
Fleets, not assistants
Agents start to outnumber engineers. Nothing scales past a handful of them without shared, trustworthy, machine-checked context.
Agents can write code in seconds. As code becomes cheap, the scarce thing is the understanding behind it. Autonomy depends on trust, and trust depends on knowledge. Every extra bit of autonomy multiplies the cost of one wrong assumption. That's why a layer that grades and re-checks its own claims matters right now.
We don't have to beat Cursor or Claude Code. We need every one of them, and every agent a company writes itself, to be measurably better on that company's repositories than on anyone else's. An easier bet, and a much harder thing to displace.
Why it's hard to copy
Correctness comes from how it's built, not from asking a model nicely.
| Who | What they answer | Where they stop |
|---|---|---|
| Coding agents | “Write this code.” | No lasting memory of your reasoning. They re-read cold, repeat mistakes you already corrected, and leave no trail. |
| Code search | “Where does this appear?” | Returns things that look like your words, not things that meet a condition. Can't tell “nothing exists” from “I didn't find it”. |
| LLM graph RAG | “Summarise this corpus.” | Structure inferred statistically and served at one flat confidence. A grade you didn't earn is worse than none. |
| Wikis & ADRs | “What did we decide?” | Depend on discipline and go stale without anyone noticing. The failure mode is a confident wrong answer. |
| Harness memory | “What did I tell this agent?” | Cursor memories, CLAUDE.md, mem0: one silo per tool, ungraded prose, never re-checked against the code, invisible to the rest of the org, gone when you switch tools. |
| Rafinery | “Why is this here, what breaks, and can I trust the answer?” | Linked to the code, graded, self-repairing at the merge, across repos, works with any agent. It makes all of the above better instead of replacing them. |
Won't the coding tools just do this? They're trying. Every tool is growing its own private memory, and that is the problem: N agents with N ungraded silos is exactly the fragmentation that makes one graded, tool-neutral graph necessary. The asset belongs to the customer, lives in their repositories, and is worth nothing outside their account. That is the layer a neutral third party is best placed to own, and the one every tool wants to read from.
apps/web/components/marketing/_data/content.ts → MOATS modeled competitor column is judgement from public behaviour.Traction
One founder, 54 days, 623 commits. Live, published and measured.
In 54 days, one founder built the core platform: 4 packages, 5 agents with evaluation suites, a 250-node, 423-edge knowledge graph, GitHub integration, merge-time reconciliation, and a public demo.
4 packages shipped
cli 0.19.1 · okf · knowledge · retrieval
623 commits · 104 test files
in 54 days, about 12 a day, since 5 July 2026
5, each with an eval suite
atlas · prism · bloom · compass · sage
250 nodes · 423 edges
279 machine-verified · 0 dangling
A published A/B write-up
−51% tokens, 0 correction rounds. Method and raw numbers public
Public demo
anonymous visitors get the real product read-only, not a mock
GitHub App + reconciler
runs on merge; needs nothing from anyone's laptop
Pre-revenue
Pre-revenue, no external users yet. Our first three design-partner slots are open. The first paying org is the next milestone, not a past one.
apps/web/components/marketing/_data/content.ts → FIGURES counting commands sit beside the numbers in source and are re-run before every editHow we make money
We price against a bill the customer already pays.
| What a developer spends today | agent tokens, one developer, one month. Observed, not surveyed | ~$500 |
|---|---|---|
| What the graph removes | cold re-reads and correction rounds, the two things it prevents by design | 30–40% |
| = saved per developer, per month | before counting the human review round that never happens | $150–200 |
| What we charge | one number, seats only, everything included | $39 |
Single developer, for ever
Installed into their own repo, shadcn-style; they own the copies. No account, no approval, nothing to sign. Ships at general availability; during preview, access is by invite.
Its job is distribution. It has to be genuinely good.
$39 / developer / month
Platform sync · MCP serving to every agent they run · org, seats and roles · the reconciler at every merge · cost and quality trends · Slack and kanban agents. No per-repo fee, no tier games.
60-engineer org ≈ $19K a year.
Priced per organisation
SSO and SCIM · audit export · region pinning or self-host · key policy · SLA. We haven't set this number because we haven't earned the right to yet. It follows SOC 2 and the first ten customers.
Not before we've been through one real security review.
We'd rather be obviously cheap than clever. The price has to be a rounding error next to the saving, or a finance team does the maths and we lose. Token prices will keep falling; the cost of a wrong merge won't. The lasting line item is the correction round and the human review that never happen. The token saving is just the part we can invoice against today. Later, as fleets grow, the same graph is metered per agent and per query, so revenue tracks a customer's autonomy rather than their headcount.
Market
Per-seat pricing is the way in, not the market. Once agents outnumber engineers, knowledge stops being a licence and becomes metered infrastructure, and the same graph bills per agent and per query without a second sale.
| A · Share of engineering work | ~30M professional developers × ~$85K fully loaded ≈ $2.4T of engineering work a year. ~25% executed autonomously by 2032 → ~$600B. Context and knowledge infrastructure takes ~3.5% of it. | $21B |
|---|---|---|
| B · Metered consumption | ~30M engineers each supervising ~10 agents = ~300M agents, at ~200 grounded queries a day, at $0.001 a query. | $22B |
| Today's wedge | ~46,000 organisations already run agents in production, at the ~$19K seat ACV on the previous slide. This is what we can bill in 2027: 4% of the market it opens onto. | $0.9B |
Team
Built solo. That's the proof, and the constraint this round removes.
Rohik Galli
Designed and shipped the contract, the CLI, four published packages, five agents with eval suites, the knowledge graph, the reconciler and the platform, alone, in 54 days. Wrote the A/B write-up this pitch rests on, including the caveats that weaken it.
Engineer — knowledge graph
Query semantics, edge grading, org-scale traversal.
Engineer — platform
Tenancy, ingest, the reconciler at scale, the security posture that unblocks enterprise.
Engineer — agent surfaces
The MCP serving layer and the consumer agents: review, security, Slack, kanban, and whatever a customer writes themselves.
Engineer — forward-deployed
Lives inside the design partners. Every friction they hit becomes a product fix, not a support ticket.
- Not incorporated yet. On purpose: the product came first. Entity, cap table and the standard paperwork happen at close.
- Why solo is the proof. This is a protocol before it's a UI. One author kept the contract consistent through eleven revisions, the same discipline the graph now enforces for customers.
- Why solo is the constraint. One person can't run design partners and ship the platform at the same time. It's the top risk in this deck and the first thing the round fixes: 3–4 engineers, hired in the first two quarters.
- Advisors. Two seats reserved: a platform-engineering leader at a 500+ engineer org, and a security leader to guide SOC 2. Named on close.
git shortlog packages/*/package.jsonThe ask
We're raising to turn a working system into a paying market.
A post-money SAFE on standard terms. Size and cap in the conversation. Here's what the money does.
3–4 engineers
Knowledge graph, platform, agent surfaces, and a forward-deployed engineer if the round allows. Removes the single-operator risk first.
Three design partners → paying customers
Forward-deployed, weekly, with a written case study each: time to graph, corrections saved, gaps closed.
The served graph everywhere
Slack, the kanban board, any MCP agent. Plus SOC 2 Type II, the gate on every enterprise deal.
- 10
- paying organisations in 12 monthsthe first one is the milestone that matters
- <30 min
- a stranger's repo → a cited graph, unattendedthe gate on self-serve
- 3–4
- engineers hired in the first two quartersthe single-operator risk, removed first
The future isn't engineers versus agents. It's engineers and agents, working together on problems that once felt impossible.
For that to work, agents need the context and knowledge engineers have built up over time. Rafinery is the intelligence layer for autonomous engineering: every merge feeds the graph and every agent uses it, so the work compounds instead of starting from zero. It belongs to the customer, and it decides how much of their engineering they can safely hand to machines.
- Try it
- dev.rafinery.ai/demo
- The experiment
- dev.rafinery.ai/measured
- Install
- npx @rafinery/cli init
- Rohik Galli
- gallirohik@gmail.com