From Prolog Parsers to Symbolic-First iCommerce
Back to all articles
Symbolic-FirstAI ArchitectureiCommerce

From Prolog Parsers to Symbolic-First iCommerce

Why we moved beyond guessing LLMs to a Symbolic-First Architecture that plans, proves, and executes with auditability.

Dominic Steil

Dominic Steil

Founder & CEO at StateSet

Jan 18, 20269 min read
0% complete

TL;DR

Pure GenAI guesses. Commerce needs proof. We moved to a Symbolic-First Architecture: LLMs propose plans, a neuro-symbolic engine verifies them against rules, and durable workflows execute only what passes. It is the only path to reliable, auditable autonomy.

Where it started

This journey began in a computational linguistics class mapping English to Japanese with Prolog parsers. Turning sentences into logic trees was the first clue that language and rules belong together. That lens shaped every system we built after.

2013-2014 - Logic and linguistics

Built grammar parsers in Prolog and mapped English to Japanese. Learned to translate language into logical rules.

2015-2016 - Max, the enterprise bot

Used nforce, LUIS, and Botkit to ship Max in Slack so sellers could generate contracts from Salesforce. Earned SE MVP.

2019-2023 - StateSet and the GPT wave

Automated returns, warranties, and subscriptions; launched ResponseCX and early GPT-powered ticket drafts; pushed through early market hesitation.

2024+ - Autonomy at scale

Thousands of tickets per month, TTS, deterministic workflows, and a realization: generative is not enough without logic.

Why symbolic-first

GPT proved that LLMs can read, summarize, and draft. But in commerce, wrong decimals and missing policies cost real money. We learned that generative answers are not enough; we need logic, constraints, and proofs before actions hit production systems.

Closing the loop: the StateSet NSR Engine

We returned to the roots: a symbolic-first core with neural assist. The NSR Engine checks every proposed action, returns counterexamples when rules break, and only then lets workflows run.

Hybrid Reasoning Engine

Plan → Act → Reflect loop decomposes complex asks into solvable steps with explicit feedback.

Logic Engine

Prolog-style inference with forward and backward chaining so plans are proven before execution.

Program Synthesis

Generates small scripts to solve math and data tasks that LLMs would otherwise guess at.

Advanced cognitive primitives

MCTS

Monte Carlo Tree Search to explore and score multiple reasoning paths before acting.

Graph of Thoughts

Non-linear reasoning that can branch, merge, and backtrack instead of one linear chain.

Symbolic first

LLM calls are last resort; logic, plans, and knowledge bases are first-class citizens.

Autonomous commerce in action

Consider the VIP auto-refund rule. A probabilistic chatbot might hallucinate policy. The NSR Engine evaluates explicit rules before touching money or inventory.

  1. Check issue type equals damaged_on_arrival.
  2. Check customer tier equals VIP.
  3. Check order total under 500.
  4. Actions: authorize refund, waive return shipping, respond with VIP template.
{
  "rule": "vip_doa_auto_refund",
  "if": [
    {"fact": "issue_type", "args": ["?ticket", "damaged_on_arrival"]},
    {"fact": "customer_tier", "args": ["?customer", "vip"]},
    {"fact": "order_total", "args": ["?order", "?total"]}
  ],
  "constraints": [
    {"op": "<=", "left": "?total", "right": 500.0}
  ],
  "then": [
    {"action": "authorize_refund", "args": ["?order", "full"]},
    {"action": "waive_return_shipping", "args": ["?order", true]},
    {"action": "respond_with", "args": ["?ticket", "instant_vip_refund_template"]}
  ]
}

Output is commands to payments, logistics, and CRM. It is auditable, safe, and fast.

The future of intelligent commerce

We call it iCommerce: an operating system where LLMs propose, neuro-symbolic engines verify, and neural controllers execute. Broad language coverage meets deterministic execution and replayable workflows.

Workflows without intelligent agents will soon feel as dated as grammar trees on a chalkboard. The difference is that these trees now think, verify, and run the next generation of software.

Move from guessing to proving

Deploy symbolic-first agents that plan, verify, and execute with a proof trail across your stack.

Talk with StateSet

Enjoyed this article?

Get more insights on autonomous commerce, AI agents, and margin intelligence delivered to your inbox.