“Can we let the chatbot handle the first pass?” Sales asked. “Not unless it can guarantee we aren’t selling something we can’t build,” operations replied.

Both are right. You want the flexibility of AI to capture messy requirements fast. You also need the certainty of rules so every quote is buildable, priceable, and defensible. You don’t get that by picking a side. You get it by stacking them.

Here’s the simple idea teams miss: put a conversational layer on top of a deterministic layer. Let the AI talk. Let the rules decide.

Why Two Layers Beat One

Most CPQ pain isn’t about UI or missing features. It’s about trust. Sales needs to know the configuration is valid. Finance needs to know the price holds up. Product needs to know the rules won’t be quietly bypassed the moment a deadline hits.

Generative AI is brilliant at turning emails, PDFs, and half-finished notes into a coherent story of what the customer wants. It also produces different answers to the same prompt on different days. Gartner has been clear on this point: generative systems are probabilistic and require guardrails in production workflows. That non-determinism is a feature for discovery - and a risk for quoting.

Rule-based configurators are the opposite. They are consistent, auditable, and sometimes painfully rigid. They won’t guess. They will block.

AI collects intent. Rules certify reality.

Put them together and you get speed without gambling on correctness.

How the Two-Layer CPQ Works

I run this approach with teams selling complex products. The flow is boring on purpose - boring is good when money is on the line.

Layer 1 - Conversational capture: An LLM chats, reads, and organizes. It handles the fuzzy front end - needs, constraints, preferences, trade-offs. It can ask clarifying questions in plain language and highlight contradictions. It creates a structured requirement set.

Layer 2 - Deterministic validation: A symbolic engine enforces hard constraints and pricing rules. It tests the requirement set against allowed combinations, dependencies, and price logic. It returns a valid configuration or precise conflicts to resolve.

This isn’t AI vs rules. It’s AI before rules.

A few design choices make this work in the real world:

  • Separation of concerns: Requirement capture is free-form. Configuration enforcement is not. Keep them apart so you don’t pollute requirements with solver-specific artifacts.
  • Explainability trail: For every accepted or rejected choice, capture a why. The LLM can translate solver messages into human language. Without an explanation, adoption stalls.
  • Composable interfaces: A thin API between the two layers makes it easy to swap the conversational UI, the solver, or pricing methods without rebuilding the whole stack.
  • Test suites, not demos: Treat rules like code. Version them, test them, and publish red-green results with every release. A passing demo doesn’t mean the system is safe.

If the system can’t explain itself, sales will explain around it.

Notice what isn’t happening. We’re not letting the LLM “infer” compatibility or pricing. We’re letting it express intent and guide the user, then delegating all hard checks to a solver that behaves the same way on Tuesday as it did on Monday.

Practical Rules for a Safe, Fast Hybrid

These rules come from real projects - the ones that keep working after go-live.

Rule 1: Separate requirement capture from enforcement. Don’t let the chat steer the solver directly. The conversational layer creates a requirements object. The solver validates it. Example: the user says “long-haul, heavy loads, noise-sensitive city deliveries.” The LLM maps that to variants and parameters. The solver decides if those can coexist.

Rule 2: Feed the AI with context, not secrets. Give the LLM modules, variants, constraints at a readable level, plus trade-off explanations in plain language. Keep deep manufacturing rules and cost data behind the solver. You want helpful guidance, not a leaked price book.

Rule 3: Keep a human-readable why. For every constraint failure, store a short explanation the chat can surface: “Sleeper cab requires High HP engine due to weight and torque targets.” This turns a blocker into guidance.

Rule 4: Price with learning, validate with rules. Use price logic the solver can enforce, then let the conversational layer capture deal context that improves pricing over time. Start with ranges and fences if needed. Pricing improves through use, not waiting for perfect data.

Rule 5: Name and avoid the Ventriloquist Bot. The anti-pattern is an LLM pretending to be a configurator. It sounds confident, it occasionally hallucinates, and it cannot guarantee validity. If the output doesn’t pass a deterministic check, it’s a draft - not a quote.

Speed should come from guidance, not from skipping checks.

Each extra rule adds a cost to future change - keep rules small and testable.

What to Do This Quarter

Don’t make this a two-year platform project. Make it a 90-day capability shift.

  • Inventory product context: For one product line, assemble a lightweight catalog of modules, variants, key dependencies, and short trade-off notes in plain language. You’re creating the AI’s briefing pack.
  • Stand up the thin API: Expose a simple endpoint the chat layer can call: submit requirements, get either a valid configuration + price or a conflict list. Keep it boring and well-logged.
  • Add tests before you add prompts: For every rule you care about, write a deterministic test. Publish a green bar on each release. If you can’t test it, don’t ship it.
  • Pilot with real emails: Feed actual customer emails or RFP snippets into the conversational layer. Measure how much back-and-forth it eliminates before engineering has to get involved.

What you’ll see quickly: the AI reduces the interpretation load and the solver reduces the error rate. Sales moves faster because they aren’t stuck translating vague requirements into feature codes or waiting for an expert to sanity-check the configuration.

The Compounding Advantage

Once this pattern is in place, everything gets a little easier every week. The conversational layer keeps learning how to ask better questions and present clearer trade-offs. The rule layer stays stable because you’re adding small, tested constraints instead of one giant logic dump.

The winners are the teams that separate thinking from checking. Thinking happens with customers, in language they understand. Checking happens quietly, consistently, and leaves an audit trail. The laggards will keep polishing forms and arguing about mandatory fields while their best sellers route around the system.

There’s nothing revolutionary about the tech here. The shift is treating AI as the expert’s apprentice and the solver as the inspector. One explores. The other certifies. Together, they earn trust.

The quiet truth is simple: the fastest quoting process is the one everyone believes.