What the fuck is neurosymbolic AI?

It turns out the idea I've been shaping has a name.

For the past few weeks I've been exploring one question, and it has slowly turned into something more than an idea. What if everything a business runs on could set itself up, and then keep adapting as the business changes? Not a better CRM. A whole operating system for a business, one that nobody has to configure.

I went at it the slow way. I read research papers and old standards. I drew the loops on a whiteboard. I tested ideas on real data and watched most of them fail. Each time something broke, I asked why, and then why again, until I reached something that held.

Today I watched Frank Coyle's talk "Why Agentic Systems Need Ontologies" from this year's AI Engineer World's Fair. He described, fairly precisely, the shape I had arrived at. He also had a name for it: neurosymbolic AI.

I'll admit that's a bit funny. It's like I invented a recipe and then finding out it's a dish with a name and a Wikipedia page. But it's also reassuring. When you reason from first principles and land where other people landed, that's a decent sign you're not crazy. So here is what the term means, without the fancy words, and why I think it matters for what I'm working on.

The problem: a business runs on a pile of tools

Look at how a small business runs today. Contacts live in a CRM. Tasks live in a to-do app. Projects live in a project tool, bills in invoicing software. Then there's the calendar, the inbox, and the spreadsheet nobody admits to. Each tool has its own idea of what a client is, and its own fields to fill in. You are the glue. You copy the same name from an email into three places and hope they stay in sync.

Each of those tools also assumes someone will set it up: pick the fields, define the stages, write the rules. Large companies pay people to do that. Most businesses don't have that person, so the tools stay half-configured and the real state of the business lives in someone's head.

The tempting move today is to put AI into each tool. An AI CRM, an AI to-do list, an AI invoicing app. That's a one-to-one replacement of the old stack, seams and all. I think we can see past that now. The work itself was never split into categories. Someone asks for something, you agree, you do it, you bill it, they pay. The tools carved that up because software used to need fixed screens and fixed fields. Now that AI can read the messy stuff, a business can have one model of itself. "My clients", "my to-dos" and "what's unpaid" become views on that model, not separate products.

So the bar I set is a business operating system that configures itself and adapts as it goes. Nobody sets it up. The most you do is say yes to connecting your mail, calendar or bank. It's useful from the first hour: each thing that needs you shows up with a few buttons and gets handled in place, not in a long chat where things scroll away (that's the other idea I'm exploring: the work lives in the object, not in the chat...more on that in another piece). And it learns the business as you work, instead of asking you to describe it.

The obvious way to build that is to hand an AI agent everything and let it run. I tried versions of that. It looks great in a demo. On real work it fails in the way that matters most: it is wrong quietly and with confidence. A list written purely by the AI included things that weren't there, and dropped things that were. In a business, a forgotten promise or a missed invoice costs you a client.

The idea: the AI proposes, the rules decide

Neurosymbolic AI is a mouthful for a simple split. There are two kinds of machinery, and each does what it's good at.

The neural half is the language model. It reads messy things, guesses what they mean, and imagines what could happen next. It is brilliant and unreliable, like a talented intern on their first day.

The symbolic half is things written down explicitly: what kinds of things exist in the business, what each one must have, and what rules apply. Plain code checks against it. It has no imagination at all, which is the point. It gives the same answer every time.

The trick is who gets the last word. In my design it works like this:

  1. The AI reads an email and proposes what it means.
  2. Plain code checks the proposal against the model of the business.
  3. Nothing is written down until the check passes.
  4. Anything that leaves the building, like a message or a payment, has either a precise rule and policy for it, or waits for a person's yes.

Say a client writes: "Can we move Thursday's session to next week? And could you resend last month's invoice? I lost it." In today's stack that one message touches three tools: the calendar, the project and the invoicing. Here it's one message about one client in one model. The AI proposes two things: a request to move a booking, and a request to resend a bill. The code then asks dull questions. Is there a Thursday session to move? Is next week free? Is there an invoice for last month, and is it already paid? If the AI later claims the client paid, where is the payment? A hunch is not a receipt.

Coyle checks in two layers, and so do I. First the shape: is the date actually a date, is the amount actually a number. Then the sense: does this step make sense for this business right now. Shape is easy. Sense is where the model of the business earns its keep.

That model has a name too. It's an ontology, which sounds grander than it is. An ontology is a written-down answer to two questions: what kinds of things exist here, and how do they relate? Clients, jobs, promises, payments, and who owes what to whom. Accountants have had one of these for decades. It's called REA, for resources, events and agents, and it dates from 1982. I based my design on it before I knew it counted as an ontology.

One more thing I had done without the vocabulary. The record of what happened is never edited, only added to. Where each job stands is worked out from that record, not stored. Programmers call this event sourcing. I called it "don't let the AI rewrite history".

The hard part: a model nobody designed

Here is where my problem differs from most of what you'll read about knowledge graphs. Those models are usually designed upfront by experts. Someone sits in workshops for months and decides what a "customer" is.

Most businesses can't afford that, and things change too fast for it anyway. So the model has to grow from the work itself. A vet clinic and a design studio both have clients and bills, but a vet has patients with four legs and a studio has projects that go through rounds of revisions. Nobody should have to tell the system that. It should notice.

So the types themselves are stored as data, not baked into the code. When something new keeps showing up, the AI proposes a new kind of thing. The code stores it with a version and a source, so it can be undone. Software people have a name for this as well: an Adaptive Object Model. It also comes with a known failure. These systems tend to become very hard to understand. I take that seriously. My rule is that if a part can't be explained to a 15-year-old, the part is probably wrong.

Coyle says building the model bottom-up, from what people actually do, is legitimate. He doesn't give a method for it, at least not in this talk. As far as I can find, nobody has a good answer yet for a business structure that configures itself. That's the part I'm working on now.

The direction I like is a kind of distilling. When the AI makes the same judgment the same way, and it keeps turning out right, that judgment becomes a fixed rule, with a link back to the cases it came from. Over time more of the work moves from the AI into plain rules, and the AI only sees the cases that are actually new. The graph engineering talk I mention below describes the same move: instructions written as prose get compiled into fixed steps. The system gets cheaper, more predictable and easier to explain the longer it runs. Most software goes the other way.

The twist: two kinds of rules

After the talks I went digging, and found the part I had been fuzzy about. "Symbolic rules" sounds like one thing. It's two, and they behave in opposite ways.

The first kind reasons. The standard ontology languages, the ones with acronyms like OWL, are built to work out what else must be true. Say your model has a rule: a bill has exactly one payer. The AI misreads an email and records two different payers on one bill. You'd expect an objection. Instead the reasoner concludes that the two payers must be the same person, and carries on. Or say only teachers teach, and the AI writes down that someone teaches a scooter. The reasoner decides the scooter is a student. That's not a bug. These languages assume that anything not stated might still be true, which is useful when you're joining up knowledge from many sources. As a guardrail, though, it explains your errors away.

The second kind polices. It checks what's there against what's required, and says no. The ontology world has this too: SHACL, a W3C standard, checks a graph against the shapes it must have. And both talks put this kind in charge. Coyle checks types, then business rules, and holds back any real-world effect until the proposed action passes. Zach Blumenfeld's talk, "Make Your AI Agents Predictable With Graph Engineering", goes further. Hard rules run first and approve, deny or leave a case open. Only the open cases reach the model. The model's own sense of how sure it is doesn't get to decide when a person steps in, because it isn't reliable. And every outcome leaves a trace of why it happened.

So the lesson isn't that ontologies can't guard. It's that you have to pick the right kind of rule for the job. The AI does the reasoning. The rules do the policing. In my design, when the AI's output contradicts the model, the code flags it. It never quietly resolves the conflict by deciding something new about the world. Deciding that two names belong to the same person is a judgment, and judgments get written down with who made them and why.

I like that. The clever machinery goes where cleverness helps, and the boring machinery goes where being wrong is expensive.

Why I think this matters

The current fashion is to give an AI agent more freedom and hope. The neurosymbolic idea says something more modest. Let the AI do what it's uniquely good at, which is reading and imagining. Keep it away from the places where being wrong costs money or trust. Write those down as rules that a plain program can check.

For running a business, that split is the whole game. You don't need a system that's right most of the time and creative about the rest. You need one where you can ask "why did you do that?" and get a rule and a source, not a shrug. And you need it to work without anyone ever setting it up.

I'm not done. Some of my tests pass and some fail, and the failures are the interesting part. But the contours are clear now:

  • One model of the business, with views on top, instead of a tool per job.
  • The AI proposes, plain rules check, and a person decides anything that leaves the building.
  • What happened is recorded and never rewritten.
  • The model grows from the work instead of from a workshop.
  • Good judgments slowly harden into rules, so the system gets more predictable as it learns.
  • When something doesn't fit, it gets flagged, not explained away.

So, what the fuck is neurosymbolic AI? It's letting the AI dream and making the rules check its homework. Apparently I've been designing one for weeks. At least now I know what to call it.