Structure at Two Scales

Last October I published a piece called "From the Semantic Web to Semantic AI." I have been going back through the record I put out while we were building BeMo, checking each claim against what building it actually taught. This edition is about the biggest thing that essay got right, and about the half of the problem it never mentioned.

What I claimed

The October piece told a twenty-year story. Tim Berners-Lee's Semantic Web imagined information "structured so machines could understand relationships, context, and meaning," and it stalled because it required the whole world to hand-tag its data. My argument was that AI finally closed that gap from the other direction: "Instead of demanding that the world mark up its data, today's systems discover structure dynamically." I pointed at the failure mode of plain chat: ask a model to actually use what it knows and "the model knows the data exists, but it can't treat that knowledge as data. It dissolves back into language." And I placed BeMo at the fix. In BeMo, a conversation about a funder returns a structured entity, not prose. Meaning without structure is just language; conversation would be where structure came from.

That claim held. It is the closest thing BeMo has to a founding technical thesis, and a year of building has only hardened it. When you ask BeMo about a funder today you get a persistent, typed object that your later work can reference, sort, and build on. Score it: held.

What the essay never mentioned

Read the piece again, though, and notice what is absent. Every example structures knowledge one conversation at a time, inside one organization. The grant manager asks about STEM funders, the answer becomes entities, the entities become institutional memory. The unit of structure is always the conversation, and the beneficiary is always the org having it.

Nowhere does the essay mention that most of what a nonprofit needs to know is not inside its own conversations at all. It is in the public record. Every foundation in America files a 990. Every federal award is published. The sector's actual funding behavior, who gave what to whom, in what amounts, in what fields, over what years, sits in the open, in tens of millions of rows. No amount of conversational structure gets you that. You cannot chat your way through nine million grant records.

So the honest scorecard is that I described structure at one scale and missed that it comes at two. Conversation produces your organization's half: your plans, your funders, your history, your work. Computation produces the world's half: the public record, resolved and connected, at population scale. The essay treated the first as the whole story. The second never appears in it, and at the time, nothing in our architecture produced it.

What we built instead

This summer we built the second half. It is a separate data plane from the product: a lakehouse that takes the public record in raw form and refines it in stages until it is something the product can serve. The whole sector's 990 filings become a canonical registry of about 3.4 million organizations. Private foundation grants, federal awards, and federal pass-through dollars become one unified funding graph, currently about 12.6 million edges. Open federal opportunities refresh on a weekly cycle. When you open a funder in BeMo today, the profile, the giving history, and the similar-funder view are all reading from that plane.

The hardest problem in it is not volume. It is identity. The same organization appears under different names across sources, and a graph built on sloppy matching is confidently wrong, which is worse than empty. We made one rule early: never mint a false identity. Matching is precision-first, and when the evidence is ambiguous the system holds the record as unresolved for review instead of guessing. A smaller graph you can trust beats a bigger one you cannot, because every question downstream inherits the join.

The cluster I didn't need

Here is the confession inside the confession. My last job before BeMo was chief data officer at a real estate data company, where computing anything across the whole population meant a Spark cluster: distributed jobs, a data platform team, real money. When it became clear BeMo needed sector-scale computation, that was the instinct I budgeted with. This is Databricks-shaped work. Price a cluster.

The 2026 answer is one machine. The entire pipeline, from raw filings to the served graph, runs on a single box: columnar files on object storage, an open-source query engine over them, an orchestrator to keep the stages honest. Work I used to schedule across a cluster finishes over a coffee. Ten years of quiet progress in file formats and single-node engines collapsed the cost of an entire category, and I did not notice until I priced the job with fresh eyes instead of old instincts.

That collapse cuts both ways, and it is worth saying plainly. It means a two-founder company can build what recently required a platform team. It also means the pipeline itself is not the durable part. The durable part is what the computation is joined to. The world's record only becomes useful when it connects to what your organization knows about itself, and that join is exactly where the two scales of structure meet: the half the world publishes and the half your own work produces.

What changed in BeMo

The October essay said conversation turns language into structure, and that held. What building the beta added is the partner claim the essay was missing: computation turns the public record into structure, and the product's job is the join between them. In one sentence, the delta: I believed structure would come from conversation; it turns out conversation structures your knowledge, computation structures the world's, and neither half is the product without the other.

Then: structure comes from dialogue. Now: structure comes at two scales, and we had to build the second one. What we got right was the thesis. What we got wrong was thinking one scale of it was enough.