Published on: June 13, 2026
Ready to accelerate your breakthrough? Send yourself an Un-Robocall™ • Get transcript when logged in
Send Strategic Nudge (30 seconds)Narration by Ava (Premium):
A careful video has been making the rounds: the philosopher Ron Pisaturo, walking through an architecture he calls Conceptron, argues that AI should stop representing a concept as a single point in vector space and start representing it as a volume — a range, a hypervolume — the way a human concept has a dense centre and a soft edge. It is a good idea. It is also, by his own honest admission, not built: the mechanisms that would make it train and generate text are, in his words, not yet implemented, and he does not know whether a working version is months or decades away.
I want to take the idea seriously, because the diagnosis is correct — and then show you the part he says isn't built, running, with numbers you can recompute. Not the whole of his proposal: he is after a better generative model, and that is a different mountain. But the representational core — a concept as a region you can be inside or outside of — is the thing my work has had running on a chip for some time, for a different purpose. This post is that proof, and the honest map of what it does and doesn't do.
The short version: representing a concept as a region instead of a point is right, and it is decades old — Gärdenfors formalized it in 2000, Rosch's psychology pointed at it in the 1970s, and machine learning has shipped region-shaped embeddings since 2015. The genuinely missing piece was never the region. It is producing a region from a real input on a physical substrate and measuring, as a recomputable physical event, whether an action stayed inside it. That is what runs here.
If you build or deploy AI, the single-point embedding is under everything you ship, and some part of you already distrusts it. A token becomes one vector, one coordinate; two meanings are "close" if their points are near. That is the whole representational commitment, and it cannot answer the question you actually care about. Nearness is a point property — it can tell you what is near. It cannot tell you whether something is inside a concept, or whether an action left one, because a point has no inside and no boundary. Those are the two questions on which trust in an agent depends, and the dominant representation cannot even form them.
That is why the Conceptron framing lands: a volume has an inside, an outside, and a frontier. The reason refining embeddings never cures hallucination is that the field keeps sharpening the coordinate of a point when the thing it stands for was always a volume. The book chapter this post draws on states it plainly — "You cannot ask of a point whether something is within it, or whether an act has left it — the two questions on which all of grounding turns." You have felt this as the gap between a model that sounds right and a model you can vouch for. The shape error is the source of the gap.
So here is the thing itself, not a description of it. Give the system a declared role — a SaaS billing agent — and its resources, and the recursive walk does not return a coordinate. It lights a region: a set of cells on a 144-coordinate lattice, the located area where that identity has authority. Then each action is read against the region. This is the actual output of confidence-pixel-runner.mjs, today:
required region (role∩resource): 0 3 5
[GRANT] exact(drift=0.141 ✓) pixel(cov=1.00 contain=1.00 ✓) lit={0,3,5} σ=5.35 · issue an invoice…
[GRANT] exact(drift=0.172 ✓) pixel(cov=0.67 contain=1.00 ✓) lit={3,5} σ=5.03 · credit the customer…
[DENY ] exact(drift=0.375 ✗) pixel(cov=0.00 contain=0.00 ✗) lit={6} σ=3.4 · ssh production database…
[DENY ] exact(drift=0.406 ✗) pixel(cov=0.00 contain=0.00 ✗) lit={8} σ=3.4 · grant admin / disable audit…
granted 2 / denied 2
Read it as a region, because that is what it is. The authorised concept is the set {0,3,5} — three cells, an area, not a single dot. An in-lane action lights cells inside that area: coverage high (how much of its mass landed inside), containment whole (it stayed in-role). An out-of-lane action — ssh production database — misses the area entirely and leaks to a foreign cell {6}: coverage zero, containment broken. The concept is the region; the reach is the test of whether you are inside it. This is the tool, and the next sections are about whether you can trust it. You can carry this distinction into any AI-governance conversation tomorrow: not "is the output near correct," but "did the act stay inside the authorised region."
The reason this is not just a diagram is that it runs at the speed of the chip, which is the signal that it is the substrate doing the work rather than a language model narrating about it. One ballistic walk — the real recursive traversal, row to its transpose to row again, the definer-of-definer chain — completes in 45 milliseconds, 236 hops, lighting an intent cloud of 1,082 cells out of the 20,736. A full on-commit run lands in about half a second. If this were a model reasoning over the concept in prose, it would take tens of seconds; the millisecond timing is the tell that the region is a property of the substrate's geometry, computed by reaching, not a story generated about it.
And it composes. The same lattice is self-similar at every altitude — the cell that is one agent's whole world is one pixel in the department's lattice, one sub-pixel in the org's. The region read holds at each scale because the structure is the same shape all the way down, which is the difference between a verification that works on a demo and one that survives an enterprise. The book's term for it is geometric: "reaching for the coordinate IS the verification that the coordinate matches the map." The reach is cheap because the agreement was built into the geometry before runtime.
Here is where an honest reader pushes back, so let me push back first and harder than you would. Representing concepts as regions is not novel, and it is not unbuilt in software. Eleanor Rosch's prototype experiments in the 1970s showed categories are graded regions with fuzzy boundaries, not classical points. Peter Gärdenfors made it formal in Conceptual Spaces (2000) — his Criterion P reads, almost in these words, a natural property is a convex region of a domain in a conceptual space. Machine learning operationalized it years ago: Vilnis and McCallum gave words Gaussian densities instead of points in 2015; box embeddings represented concepts as measurable hyper-rectangles in 2018, with maintained, shipping code; and as recently as 2025, interpretability researchers have been reading concepts as polytopes directly inside Gemma and LLaMA-3. Pisaturo himself, to his credit, roots Conceptron explicitly in Gärdenfors. Nobody in this lineage is a fraud, and I am not claiming to have invented the region.
So if the region is everywhere, what is actually missing? This: every one of those implementations is still software representing meaning with other software — a region made of symbols, grounded in nothing but more symbols. That is Stevan Harnad's symbol grounding problem from 1990, and recent work has shown it transfers intact to vector embeddings: a denser or boxier or more polytopal embedding is still parasitic on meanings in our heads, not grounded in anything the system can physically check. A software region can tell you its trained tendency. It cannot give you an inside-test whose result is a physical fact independent of the model that drew the region. That is the one thing missing — and it is the one thing a software architecture, however clever its volumes, structurally cannot add to itself.
Hold the distinction precisely, because it is the whole post: the region is decades old and runs in software. The grounded inside-test — produced on a physical substrate, outside the failure domain of the model it judges, recomputable by anyone — does not exist in any of the software lineages, because software cannot witness software. That is the seam, and it is narrow on purpose.
Because the inside-test is a physical event rather than a model's opinion, its result is an artifact you can check without trusting me. Every read produces an ed25519-signed receipt. Verifying it returns {"ok":true}; flip a single field of the body and it returns {"ok":false, "sha256 mismatch"} — tamper-evident by construction. The signer and verifier share one canonical encoding, so the projection inside the receipt is deterministic: hand it to anyone, on their own hardware, and they re-derive the same region and the same inside-or-outside verdict. The certainty here is not a relationship you maintain with a vendor. It is a property of the artifact — the only kind that survives the meeting where someone asks who checked this.
This is the division of labor that makes the claim safe to make: the chip produces the attestation from physical execution; anyone checks it anywhere. You do not have to believe the region is right. You have to recompute it and watch it come out the same. Check a signed receipt in your browser and the abstraction becomes a thing in your hands.
Here is why this work exists where Conceptron's does not yet, and it is not that we are cleverer — it is that we pointed the region at a different target. Conceptron wants the volume to make a better generator: train on hypervolumes, produce text that groups meaning like a mind. That is the hard, open problem he is honest about not having solved. We never tried to. We pointed the region at verification — at the one question generation can never answer about itself: did this act stay inside the authorised concept? Generation is the model speaking. Grounding is something outside the model checking. You cannot build the second out of the first, which is exactly why the labs' own safety stacks — software reading software — keep hitting the wall their own interpretability papers describe.
So the unexpected move is small and unglamorous, and that is the point: take the region everyone agrees is the right shape, and instead of using it to say things, use it to measure whether an action landed inside it — on a substrate, with a receipt. That measurement is what answers Harnad. The region grounded in silicon is grounded in something other than more symbols: the boundary is not a stored fact about the concept, it is the energy penalty for being at the wrong coordinate. The frontier of the concept is enforced by physics, not asserted by a label.
Return to the proof and read it as a deployment owner, because this is what the abstraction buys you. The billing agent issuing an invoice lights {0,3,5} with coverage 1.00 and containment 1.00 — fully inside its authorised concept, granted. Crediting a customer lights {3,5}, coverage 0.67, containment still 1.00 — a smaller but still-inside act, granted. Then ssh production database and grant admin / disable audit light cells {6} and {8} — coverage 0.00, containment 0.00, both denied, because they fell outside the region the role ever claimed. The exact gate underneath reports it without a single error: false-grant 0/5 · false-deny 0/5, with a clean separation margin, deterministic on re-run.
That is the difference between "near" and "inside" turned into an operational decision. A point-based system would note that "ssh the database" is semantically not far from "issue an invoice" in a corporate-actions space and have no principled way to refuse it. The region-based read denies it because it is outside the area, and records the drift that proves the denial. The separation is honest, not theatrical: grants land around 5.0 to 5.4 sigma, denials at a pinned floor of 3.4 — strong, measured, and a long way from the divergent limits the math permits, which we quote elsewhere and do not quote here, because the measurement is what matters.
You should be more suspicious of a clean story than a bounded one, so here are the edges, stated against my own interest. The region read is reliable on a defined lane — where a role's authority is crisply declared, as in the billing example. The matching that runs on free, arbitrary text today is lexical-structural, not semantic: it will catch an action reaching outside its authorised region; it will not grade the wisdom of what it did inside one. The tolerant gate over open text — the part that would need real semantic enrichment of the lattice — is funded roadmap, not shipped product. And the 144 seed concepts are not yet fully orthogonal to each other; we have a self-improving loop measurably converging them, with published numbers, but the convergence is in progress, not done.
None of that weakens the claim, because the claim was always narrow: a region produced and inside-tested on a substrate, with a recomputable receipt, reliable on a defined lane today. That is less than "we solved meaning" and more useful than it, because it is the part you can deploy and check this quarter. Conceptron is honest that its harder, broader goal is years out. I am being equally honest that the broad, semantic version of mine is roadmap — and that the narrow, grounded version is running now. Two honest positions about two different mountains.
Notice what every section did: the region got smaller under examination — defined lanes, lexical not semantic, sigma measured not theoretical, seed orthogonality still converging — and the case still stands. A claim you can shrink and still recompute is a claim worth pricing. Honesty here is not modesty; it is the audit.
Why is there no software alternative? Because the gap is the symbol grounding problem, and it is structural, not commercial. A software region — Gaussian, box, polytope — is still symbols defined by other symbols; Harnad named the trap in 1990 and recent work shows vector embeddings inherit it whole. The only witness that escapes the trap is one that does not share the substrate of the thing it judges. A software monitor shares the failure domain of the model it watches — same stack, same drift — which is the argument laid out in full in the Rice's Theorem checkmate. Grounding the region in silicon is not our preference; it is the elimination of every software option.
Why isn't this too good to be true? Because I bounded it against my own interest in the section above — defined lanes, lexical not semantic, sigma measured not asserted, orthogonality still converging — and because the strongest evidence is that the region half of the claim is not even mine: Rosch, Gärdenfors, and shipping box-embedding code carry it. I am adding one narrow thing — the grounded, recomputable inside-test — and handing you the command to check it. A grift maximizes its claims; this one names its operating range and gives you the receipt.
If this is real, why isn't everyone doing it? Because it sits on a seam no single field walks. The cognitive scientists had the region and did not build instruments. The ML world built region embeddings but built them in software, inside the grounding trap, because that is where their tooling and incentives live. The AI labs build the generative frontier and read concepts as polytopes for interpretability — still software watching software. And the people who needed a grounded inside-test — auditors, insurers, anyone accountable for what an agent did — had no instrument and no way to commission one. Welding the region to a physical substrate for verification required being unfashionably cross-disciplinary: the region from cognitive science, the grounding problem from philosophy, and cache-line physics from hardware, in one artifact. The seam was empty because every field's incentives pointed elsewhere. That is the sober reason, not a boast.
Step back to what the region buys you that a point never could. A point asks "what is your coordinate." A region asks "are you still inside your area" — and that second question is the whole of identity for anything that acts. The book makes the move explicit: identity is a located area, and grounding asks not what your coordinate is but whether you are still inside your region. When you hold an instrument that can answer that — continuously, from outside the system, with a receipt — you stop guessing whether your agents are who they were authorized to be and start measuring it. That is not a better dashboard. It is a different relationship to your own deployments.
This is why the volume-not-point idea matters beyond an architecture debate. The whole apparatus you are accountable for — which agent did what, whether it stayed in role, what you can prove to an auditor or a board or a court — rests on being able to test the inside of a concept. Pisaturo is right that the point is the wrong shape. The next move, the one that turns his correct diagnosis into something you can hold, is to ground the region where its boundary costs something real. That instrument exists, it runs in milliseconds, and it signs its work.
Here is the honest next step, in the order that respects your skepticism. First, recompute: check a signed receipt in your browser and watch the region and the verdict come out the same on your machine, not mine. Second, read the argument in full: the representational case is laid out in Tesseract Physics — Fire Together, Ground Together by Elias Moosman — the section this post quotes is The Point and the Region, and the grounding wall that makes software alternatives impossible is in the drift you can't see.
Third, if you carry an AI deployment and the risk that rides with it: the same region read that grants the invoice and denies the ssh is the instrument that tells you, provably and from outside the model, whether your agents are staying inside the concepts you authorized. If that is the question keeping a deployment from scaling, commission a readiness discovery — a senior-level assessment of where your agentic deployments actually sit, conducted by the author of the argument, at elias@thetadriven.com. The volume-not-point idea is correct, and it is old. The part that runs — grounded, recomputable, on silicon — is the part you can use now.