Hello, Persistent Intelligence

Before starting Graphon, I worked as an applied scientist on Amazon’s Customer Service team. Customer service gives you a particular appreciation for the distance between an answer that sounds reasonable and one that is actually right.

Closing the distance

Across the industry, the approaches to closing that distance have changed considerably.

Before ChatGPT, a common way to automate customer service at scale involved training classifiers. A customer typed “didn’t deliver,” a model identified the likely intent, and a predefined decision tree took it from there. A lot of engineering went into figuring out which branch someone belonged on.

Then language models changed everyone’s expectations.

You could take an off-the-shelf, open-source model, give it instructions, and have it interpret a request and generate a response. Zero-shot prompting made a compelling demo remarkably easy to build. Getting something consistently reliable enough for production was harder.

So the industry went deep into fine-tuning.

This was the day and age of model merging, low-rank adapters, and trying funny things with freezing different layers to see whether it made any difference. Many a PhD was burned—and is still being burned—babysitting data instead of inventing new layer-normalization techniques.

Fine-tuning helped. But enterprise knowledge refuses to sit still. Policies change. Products change. Something that was correct when you assembled the training dataset can be wrong by the time a customer asks about it. Continuously fine-tuning a model to keep up comes with its own problems.

Enter RAG.

The idea was sensible. Fine-tune the model for how it should behave—how to sound like a customer-service representative or a pirate—and use retrieval to find the latest information to feed into its context window. A policy change could go into the knowledge source without requiring another training run.

My objection is to the premise: why are we throwing away useful structure in the first place?

If we want AI to understand the information we accumulate—across our lives, our work, and all the different ways we record it—we have to take seriously how that information is organized. What happened before and after. Which explanation belongs to which demonstration. How a detail in one source changes the meaning of something in another.

That is the problem we’re building Graphon to solve.

Two graph theory PhDs walk into a bar.

Clark and I spent the better part of our youth building graph-based solutions for robots: helping them remember where they had been, navigate places they hadn’t seen, and communicate in unknown, unstructured environments.

The graphs were sometimes explicit, sometimes implicit. But the thinking was consistent: exploit the structure of the problem. What a robot observes now relates to what it saw earlier. What one robot knows might fill a gap in another’s understanding. Those relationships are useful information in their own right.

From ideas to a system

Then came the engineering.

We spent the last year or so turning these ideas into a system that could ingest real data, build and maintain that structure, and answer questions over it at scale. The system has to handle different file types, incorporate new information, and trace retrieved evidence back to the source. It has to do this at a cost and speed that make it practical to use.

The test is whether this work produces better answers.

Can it find a detail buried in a video? Connect that detail to an explanation in another source? Recover enough evidence to answer a question completely? And how does it compare with a well-tuned retrieval stack on the same data?

We think the results speak for themselves.

These results are a checkpoint on a much larger ambition: making the information we accumulate useful long after the moment we first recorded it.

Building with Graphon

Developers shouldn’t have to understand the mathematics underneath Graphon to build with it.

So we built an interface around concepts they already know: S3-style storage and search. Buckets, objects, files, queries. You put data in, and Graphon builds the structure that makes it searchable.

From there, you can run keyword and semantic searches, search using an image, or ask questions that require an agent to follow connections across multiple sources. A straightforward lookup and a deeper investigation use the same underlying platform.

That means a developer can start with search over a collection of files and build toward something much more capable without assembling a separate system for every kind of question.

For a person, the ambition is the one we started with: being able to ask about your own world and find the pieces that matter.