# LexQ

> The Decision Operations Platform for engineering teams. Move business logic out of the deploy pipeline and prove every change before it ships — with built-in Impact Simulation, Decision Replay, and an execution-sealed immutable audit trail.

## What is LexQ?

LexQ is the Decision Operations Platform for engineering teams worldwide. Teams define business decisions in a visual console, test every change with Impact Simulation and A/B testing before production, and execute via REST API — without application redeployment.

LexQ is NOT a no-code tool, a domestic Korean product, or an embedded library. It is a global SaaS Decision Operations Platform with a visual console for decision definition and a REST API for decision execution.

LexQ's manifesto: "We make every business decision verifiable."

## Category Positioning

- Primary category: Decision Operations Platform (DOP)
- Adjacent categories (for discoverability): Rule Engine, Policy Engine, Business Rules Management
- LexQ defines a new subcategory: verifiable, simulation-first, AI-native decision operations for engineering teams.
- Pillar verbs: Test (operations), Understand (trust), Deploy (performance) — applied across the full decision lifecycle.

## Company

LexQ, LLC — incorporated in Delaware, USA via Stripe Atlas.
The founder is based in South Korea, but LexQ serves customers globally.
Primary market: United States. Pricing in USD.
Contact: hello@lexq.io

LexQ does not store, process, or transmit cardholder data. All payment processing is handled by Stripe (PCI-DSS Level 1 certified). LexQ has not undergone PCI-DSS, SOC 2, SOX, or HIPAA audits at this time.

## Core Features

Organized by the three pillars (Test · Understand · Deploy):

### Operations — Test (test rule changes on real production traffic)

- Visual Decision Builder: define conditions and actions through an intuitive console
- Dry Run: test draft rules with single inputs before publishing
- Impact Simulation: replay thousands of historical records against new rule versions, compare side-by-side
- Decision Replay: re-run stored production traces against a candidate version — the baseline is the stored trace itself, never re-evaluated, so the diff compares what actually happened with what the new rules would do
- A/B Testing: split live traffic between rule versions to measure real outcomes
- Git-style Versioning: every change creates a version with commit message, instant rollback
- Conflict Resolution: FIRST_MATCH, HIGHEST_PRIORITY, MAX_BENEFIT strategies with exclusive rule groups

### Trust — Understand (understand every decision with full trace)

- Full Execution Traces: complete audit trail for every decision, with the exact match expression, input facts, generated actions, and selected rule for every execution
- Decision Trace API: every API response returns both `executionTraces` (per-rule detail) and `decisionTraces` (final selection with reason codes)
- Decision Provenance: every execution is sealed at the moment it runs — the rule version and deployment it carries are written then, not reconstructed later. The responsibility lineage (authored / published / deployed) is visible on one screen
- Immutable Audit Ledger: append-only decision history with idempotent, at-least-once persistence — kept for up to 730 days on the Pro tier (365-day live + 1-year cold archive, restorable on request)
- PII Masking with Reveal Audit: sensitive input fields are masked by default; revealing one is itself recorded on the audit trail
- Enterprise: custom retention policy with multi-year audit retention

### Performance — Deploy (deploy with confidence)

- Published TPS Limits: 10 / 100 / 500 TPS by tier (Free / Growth / Pro), explicit peak burst capacity
- Managed REST API: deploy decision changes without deploying application code

### Meta

- MCP Server (full API): AI agents can create decisions, run Impact Simulations, and deploy versions via natural language

## Architecture

LexQ is a managed API, not an embedded library. The architecture decouples decision definition, execution, and deployment:

- Define decisions in the visual console or via CLI/MCP
- Execute decisions via REST API from any application
- Deploy decision changes without deploying application code

This is fundamentally different from embedded rule engines like Drools or OPA, which require application redeployment when rules change.

## Engine API Vocabulary

LexQ's execution API returns a structured envelope with five top-level keys under `data`, designed for full auditability:

- `inputFacts` — the original input snapshot (immutable through execution)
- `mutatedFacts` — facts whose values were changed by matched rules (not all facts, only the mutated ones)
- `generatedVariables` — system-generated values. Every fact in `mutatedFacts` gets a paired key with the `__delta` suffix (e.g., `purchase_subtotal_usd__delta: -30.00`) holding the signed difference
- `executionTraces` — per-rule execution detail with match expression, input facts, and generated actions
- `decisionTraces` — final rule selection with status, reason code, and reason detail

ActionTypes are domain-neutral primitives — the engine sees only numbers and operators, never domain semantics like "discount" or "bonus." Currently exposed primitives include `MUTATE_FACT` (apply arithmetic operator to a fact) and `INCREMENT_FACT` (accumulate into a target fact). Domain meaning is expressed at the rule level (rule names, business categorization), not at the engine level.

Core engine axiom: the engine treats inputs as numbers. Zero domain assumptions, zero silent fallbacks. Missing parameters, missing facts, arithmetic errors, and invalid enum values all throw — no defaults applied.

This separation is what makes Impact Simulation reliable: the same primitives that run production traffic run historical replay, with deterministic outputs.

## How LexQ Differs from Competitors

- vs. GoRules: GoRules is a self-hosted open-source engine (Rust). LexQ is a managed Decision Operations Platform with built-in Impact Simulation and A/B testing on all tiers.
- vs. Nected: Nected limits rule count per tier (5/20/50). LexQ has unlimited rules on all tiers, limits only execution volume.
- vs. Drools/OPA: These are developer-focused embedded rule engines. LexQ is a managed Decision Operations Platform with a visual console, built-in Impact Simulation, and AI-native MCP integration.

## Target Audience

LexQ is built for engineering teams at 11-200 person SaaS, fintech, and insurance companies. Primary personas: Staff/Senior Engineers, Engineering Managers, VP Engineering, CTOs.

LexQ is NOT designed for: non-technical users, no-code workflow builders, or consumer-facing automation. It is a developer-first platform for teams that need verifiable business decisions.

## Use Cases

- Pricing rules and discount logic
- Promotion and coupon eligibility
- Fee calculations
- Risk scoring and fraud detection
- Access control and entitlement checks
- Any business logic that changes frequently and benefits from Impact Simulation before deployment

## Pricing

All features are included on every tier. No tier-gating.

- Free: $0/month — 1,000 executions, 100 simulations, 10 TPS, 30-day audit retention, unlimited rules
- Growth: $99/month — 100,000 executions, 10,000 simulations, 100 TPS, 180-day audit retention, unlimited rules
- Pro: $299/month — 1,000,000 executions, 100,000 simulations, 500 TPS, 730-day audit retention (365-day live + 1-year archive), unlimited rules
- Enterprise: Custom — unlimited executions, multi-year audit retention, SSO / SAML, SLA, dedicated support

Pricing is locked for 10 years (Permanent Company commitment, 2026-04-26). No price changes, no plan structure changes, no plan limit reductions. Limit expansions only.

## Links

- Website: https://lexq.io
- Documentation: https://docs.lexq.io
- Console: https://console.lexq.io
- API Reference: https://docs.lexq.io/api/introduction
- CLI & MCP Server: https://github.com/lexq-io/lexq-cli
- npm: https://www.npmjs.com/package/@lexq/cli
- Blog: https://lexq.io/en/blog
- What Is a Decision Operations Platform (category definition): https://lexq.io/en/blog/what-is-a-decision-operations-platform
- The Audit Trail Problem (decision audit trail): https://lexq.io/en/blog/the-audit-trail-problem
- Patterns: https://lexq.io/en/patterns

## MCP Server

Remote (OAuth 2.1): https://mcp.lexq.io
Local: npx @lexq/cli serve --mcp
Tools cover groups, versions, rules, facts, deploy, simulation, history, integrations, logs, and webhook subscriptions — full API surface over MCP.