primitiveAI can reason about almost anything. Someone still has to decide what it's reasoning about.
That decision — what counts as an object, what counts as state, which relationships matter, where one system ends and the next begins — happens before the model does anything. Get it wrong, and no amount of intelligence saves you.
Primitive is an applied research and engineering lab. We build AI from that decision outward — then benchmark it against the boring, cheaper way of doing things to find out whether any of it was worth it.
No belief gets to skip the evidence.
Enter the Lab See the Evidence
- Intro
AI can reason about almost anything.
- I · Emergence
Contract the noise.
- II · Discontinuity
Trace the system.
- III · Recurrence
Someone still has to decide what it's reasoning about.
- Resolve
Expand what works.
Start
The model was never the hard part.
Models are already extraordinary. The hard part is everything around them —
what counts as state,
what depends on what,
what to remember and what to drop,
what changes when the context does,
where uncertainty is allowed to live,
and how you'd even know if it worked.
Get that wrong and a better model just makes a broken system faster.
The breakthrough usually isn't a bigger model
It's a better map.
We think information comes first.
Not files or databases — something more primitive. Difference. One state that could have been another.
Enough differences interacting make a pattern. Some patterns persist. Some get stable enough that the rest of the system starts treating them as a thing — and a new thing exists. Then it happens again.
That's the whole engine. State, difference, relationship, recurrence, emergence — and around again.
The primitive may not be the thing. It may be the change.
That's a belief. Not a result.
Primitive takes an information-first view of systems. We suspect that state, difference, relationship and change describe many systems better than starting from isolated objects does.
That position has ancestors — information theory, cybernetics, complexity science, physics, philosophy. The interpretation is ours. We have not demonstrated the informational foundations of reality, and we're not going to pretend otherwise.
What we can do is ask a smaller, more useful question: if we build computational representations from these ideas, do they actually help?
That one's testable
We reserve the right to speculate wildly. We do not reserve the right to call speculation evidence.
So we test it.
Contract. Trace. Expand.
The practical method underneath most of the work.
01 — Contract. Reduce the problem until the structure that matters becomes visible. What's actually happening? What's signal, what's noise? Where are we drawing the boundary — and which assumptions got smuggled in just because they're familiar?
02 — Trace. Map the system as it is: objects, states, relationships, constraints, information flows, decisions, dependencies, feedback, uncertainty, failure modes. Not to make a beautiful diagram — to know what has to stay true when the diagram becomes software.
03 — Expand. Build outward from the smallest representation that still preserves what matters. Add models, agents, memory, tools, interfaces — only when they earn their place.
Complexity is allowed
Unnecessary complexity isn't.
The framework underneath it all.
Primitive is developing Recursive Field Theory — RFT. It started as an irritation: systems that had nothing in common kept producing the same representational problem.
A conveyor network. A shortest-path problem. Human behaviour. Memory. Neural networks. Markets. Agent systems.
Different domains, different vocabulary — and underneath every one of them: states, possible relationships, actual interactions, changing context, recurring patterns, and larger structures emerging from those patterns.
RFT asks whether that recurrence can be formalised into something computationally useful. Its hardest question is also its simplest:
And once it does — what can that new thing do?
Status: FORMALISING / EXPERIMENTAL
Explore Recursive Field Theory
When does a pattern become a thing?
Ideas are allowed to lose here.
Primitive is a lab because not everything we build should become a product. Some things exist to answer one question. Some exist to test a representation. Some exist because the idea was strange enough that we needed to see what happened. Some fail — and those stay, because they're useful.
Papers — formal arguments, methods, research.
Experiments — one question, tested under controlled conditions.
Benchmarks — comparisons against deliberately boring baselines.
Builds — implementations worth taking past the notebook.
Lab Log — the chronological record: decisions, changes, mistakes, surprises.
Failures — ideas that didn't survive contact with reality.
This is the notebook, not the highlight reel.
Money. Mouth. Evidence.
If Primitive says one representation beats another, there's a test. If we say a system is cheaper, there's a cost figure. If we say it retrieves better, there are known-answer questions. If we say it needs less context, we count the tokens.
The benchmark exists before the victory lap.
Where it's practical, we publish the specification, the dataset, the frozen prompts, the model config, the evaluation criteria, the raw outputs, the costs, the failures, and the code to reproduce it.
We don't benchmark the demo. We benchmark the claim.
Told You So™
Predictions are easy to remember correctly after they come true. So occasionally we make it harder for ourselves.
We write the prediction first. Freeze the criteria. Seal the file. Publish its cryptographic fingerprint before the outcome is known.
Then reality does whatever it wants — usually without consulting us.
When the result is knowable, we reveal the original and anyone can verify it against the fingerprint we committed earlier. Change one character after the fact and the hash won't match. If we were wrong, the prediction stays public. If we were right —
well.
Told you so.
Research is useful when it changes what you can build.
Primitive takes on the problems where the hard part is understanding what's actually happening before deciding what technology belongs there — complex workflows, fragmented knowledge, uncertain information, human judgement, changing context, systems nobody ever fully mapped.
We investigate the system first, then decide where AI belongs. Sometimes that's a sophisticated agent architecture. Sometimes it's a very small automation. Sometimes it's fixing the information architecture before a model is touched at all.
The objective isn't maximum AI
It's a better system.
Bring us the problem before you bring us the solution.
The interesting work usually starts with a sentence like:
"We know this process is broken, but nobody can quite explain why."
Good
That's enough to begin.
We think information comes first.
We think reality gets more interesting when the primitive unit isn't an isolated thing, but a distinguishable state capable of change and relationship. We think recurrence turns interaction into structure. We think structure becomes a new object. And we think that process matters to the way we build intelligent systems.
We may be wrong.
So Primitive exists to do the part philosophy alone can't.
Build it. Measure it. Publish what happens.