Direct Microservice API
Your application submits problem payloads (entities, groups, constraints) to a stable REST/JSON route and receives verified assignments with attached legality certificates. Domain solving logic stays out of your codebase.
Real-Time Operational Optimization
Mission-critical optimization. Built for live operations.
When routes, workforce rules, and capacity shift by the minute, enterprise operations need fast answers with auditable proof. Helixor Solver is designed for provably feasible GPU-assisted optimization — without the costly rewrites legacy solvers demand.
Schedule
Coverage • Rest Rules
Route
Time Windows • VRP
Repair
Live Replanning
Replan
5-Band Proof Chain
Tensor Constraint Network • Active
0
Hard Violations
Lexicographic legality guarantees no soft preference ever compromises a hard safety or legal boundary.
Live
Operational Replanning
Disruption recovery is modeled through a stable solve contract designed for fast operational replanning.
Rules
Policy Agility
Deploy new business rules through declarative manifests, without refactoring backend applications.
Typed
Validation Gates
Solver outputs are held behind manifest checks, feasibility certificates, and review-gated evidence before public result claims.
The Enterprise Optimization Dilemma
Why traditional solvers and LLMs fail mission-critical operations.
Complex operational planning has historically forced organizations into a lose-lose choice: brittle legacy OR software that takes months to adapt, or unpredictable LLM agents that hallucinate solutions.
Legacy Solvers (MILP / CP)
Rigid & Brittle
Hand-coded mathematical models and hardcoded penalty weights.
- Months to change rules: Every policy shift requires rewriting low-level constraint matrices.
- Penalty weight failures: Tuned cost weights silently purchase broken labor or safety rules.
- Combinatorial explosion: CPU branch-and-bound stalls for hours on dense multi-week horizons.
- Black-box outputs: Returns a scalar cost number without auditable proof or violation location.
Autonomous LLM Agents
Uncertified & Stochastic
Generative models attempting combinatorial constraint reasoning.
- High hallucination rate: Generates schedules that look plausible but break physical capacity.
- Non-deterministic: Identical inputs produce conflicting operational plans across runs.
- No mathematical guarantees: Incapable of proving feasibility or optimality boundaries.
- Fails open: Confidently emits broken assignments when critical data is missing.
Helixor Manifest Solver
Declarative & Provable
Neurosymbolic Tensor Constraint Networks + 5-Band Certificates.
- Declarative agility: Business rules live in versioned manifests — zero solver code changes.
- 5-Band Lexicographic Legality: Strictly prevents cost objectives from buying illegal states.
- GPU-accelerated TCN: Batched tensor reductions support fast operational re-planning.
- Machine-checkable certificates: Outputs include auditable evidence for legality bands and trade-offs.
Enterprise Deployment
Three ways to run it — one stable contract.
Deploy Helixor Solver as a direct microservice API, embed it inside autonomous Digital Workers, or orchestrate heavy distributed compute across GPU clusters.
Digital Worker Action
Embedded inside Helixor Digital Workers. The worker gathers live ERP/TMS context, verifies operational authority, calls the solver, and executes real-world changes — or holds and alerts a human operator with clear diagnostics.
Worker-Backed Control Plane
Heavier enterprise workloads automatically scale across dedicated CPU and GPU nodes. The control plane orchestrates dynamic pricing DPs and scenario rollouts across devices without changing the request/response interface.
Operational Scope
Six problem families that need provably feasible answers.
Built for high-stakes operational environments where schedules, routes, capacity, fairness, labor laws, and costs all interact simultaneously.
Complex Rostering & Shift Scheduling
Multi-week horizon nurse scheduling, class timetabling, and shift rotations under strict labor contracts, skill qualifications, rest windows, and fairness spreads.
Key Constraints: Consecutive work limits, rest periods, weekend integrity, skill matching.
Vehicle Routing & Dynamic Dispatch
Vehicle Routing with Time Windows (VRP-TW), field technician dispatch, capacity-constrained pickups/deliveries, and live multi-stop route repair.
Key Constraints: Service time windows, vehicle capacities, driving hour limits, traffic delays.
Multi-Echelon Network Allocation
Inventory positioning, distribution center cross-docking, and network-wide replenishment allocation balancing demand forecast, lead time, and service SLAs.
Key Constraints: Safety stock levels, throughput limits, supplier lead times, stockout risk.
Live Solution Repair & Disruption
Instant replanning after unexpected equipment breakdowns, flight delays, weather shocks, or employee call-outs — repairing schedules with minimal disruption ripple.
Key Constraints: Minimal change delta, immediate feasibility, downstream ripple mitigation.
Order Fulfillment & Batching
Warehouse pick-wave sequencing, 3D container bin packing, carrier allocation, and order grouping to maximize throughput and meet carrier cut-off windows.
Key Constraints: Packing geometry, weight limits, carrier SLAs, conveyor capacity.
Facility & Resource Timetabling
Hospital operating room scheduling, airport gate allocation, telecom spectrum sharing, and university course timetabling across dense shared constraints.
Key Constraints: Equipment dependencies, sterilization buffers, turnaround windows.
The Neurosymbolic Engine
Algebraic structure meets batched tensor computation.
Classical Operations Research struggles with non-linear rules and penalty-weight hacks; deep learning struggles with combinatorial constraints. Helixor's neurosymbolic engine compiles declared rules into a Tensor Constraint Network (TCN), eliminates infeasible candidates via the Helix Index, and solves via a hybrid of Rotation Column Generation and Tensor Local Search.
01 / DECLARE
Manifest Ingest
Entities, groups, slots, and business rules declared in YAML/JSON manifests against generic contract libraries.
02 / VALIDATE
Registration Gate
Pre-solve static analysis inspects rule enforceability. Catches missing inputs and fails closed with repair hints.
03 / COMPILE
Tensor Network (TCN)
Rules, occupancy, costs, and conflict structures are lowered into dense multi-dimensional device tensors.
04 / ELIMINATE
Helix Index Zip
Value and Legality strands are zipped. Infeasible candidate moves are made mathematically invisible to GPU reductions.
05 / SOLVE
Hybrid Engine
Rotation-based Column Generation (Master LP) provides structure; Tensor Local Search polishes escape moves.
06 / CERTIFY
5-Band Certificate
Dual-scorer verification emits the plan paired with an independent, machine-checkable audit certificate.
Eliminating Penalty-Weight Failures
The 5-Band Lexicographic Certificate.
In standard solvers, legality is approximated with a large penalty weight (e.g., $10,000$). In production, an objective saving of $10,001$ will silently purchase a broken labor law or safety violation.
Helixor enforces strict lexicographic priority: higher bands strictly dominate lower bands ($Band_0 \succ Band_1 \succ Band_2 \succ Band_3 \succ Band_4$). No quantity of cost savings may purchase a single hard rule violation.
BAND 0
Eligibility & Domain
Physical skill, contract eligibility, license bounds.
MUST = 0
BAND 1
Hard Rules & Compliance
Labor laws, max consecutive hours, mandatory rest.
MUST = 0
BAND 2
Unplaced & Slack Demand
Coverage floor shortages, unfulfilled shifts.
SENIOR
BAND 3
Soft Preferences & Fairness
Worker requests, weekend integrity, balance spread.
WEIGHTED
BAND 4
Objective & Financial Cost
Total wage cost, fuel expenditure, travel distance.
OPTIMIZE
Patent-Pending Core Primitive
The Helix Index: infeasibility made invisible.
Classical branch-and-bound must explore a tree branch to learn it is infeasible; metaheuristics must visit and score bad candidates to penalize them. The Helix Index pairs candidates with legality masks and zips them in a single tensor operation — eliminating infeasible moves before GPU reductions run.
Vectorized Paired-Strand Zip Mechanism
How the GPU evaluates a full candidate neighborhood in parallel without branching divergence.
Value Strand (Costs • $\Delta$)
$V \in \mathbb{R}^N$
-$120
-$95
-$45
-$180
-$60
Constraint Strand (Legality Mask)
$M \in \{0, 1\}^N$
1 (Legal)
0 (Rest Break)
1 (Legal)
0 (Max Hrs)
1 (Legal)
↓ VECTORIZED HELIX ZIP • $Z(V, M) = \text{where}(M = 1, V, +\infty_{\text{sentinel}})$ ↓
Zipped Selection Tensor (Argmin Kernel Input)
Infeasible candidates removed
-$120 [SELECTED]
+$10^{9} [MASKED]
-$45
+$10^{9} [MASKED]
-$60
Hardware Acceleration & Partnership
Accelerated on GPU. Engineered to compose with NVIDIA cuOpt.
Helixor Solver is built from the ground up for accelerator hardware — batching candidate reductions, pricing dynamic programs, and lookahead scenarios across device tensors.
NVIDIA cuOpt Integration
Complementary Layers, Built to Compose
NVIDIA cuOpt delivers world-class GPU LP solvers (PDLP, Barrier, Dual Simplex) and massive-scale routing heuristics. What cuOpt deliberately leaves open is the complex workforce modeling layer, rest rules, shift succession, and lexicographic certificates.
Helixor supplies the declarative intelligence and proof certificates; cuOpt supplies low-level GPU acceleration. Together, they solve enterprise workforce and logistics problems that neither layer can address alone.
Four Hardware Batch Axes
Where Accelerator Scale Pays Off
- Entities (Independent DPs): Per-nurse or per-vehicle dynamic programs run concurrently in parallel GPU blocks.
- Candidates (Masked Reductions): Move evaluations execute as vectorized tensor reductions over entire neighborhoods.
- Lookahead Scenarios: Anticipates future weeks by solving multi-horizon stochastic futures in parallel.
- Multi-Tenant Instances: Solves hundreds of hospital wards, depots, or field territories concurrently.
Interactive Code Explorer
Inspect the contracts: manifests, APIs, and proofs.
See how problems are declared, how the API is invoked, the machine-checkable certificate emitted, and how AI agents call the solver via MCP.
# Declarative Problem Manifest — Nurse Rostering Sample
schema_version: "helixor.solver.v1"
problem_type: "nurse_rostering"
horizon:
days: 28
shift_types: ["Early", "Day", "Late", "Night"]
entities:
- id: "nurse_01"
contract: "full_time"
max_consecutive_shifts: 6
min_rest_hours_after_night: 24
max_total_hours: 160
rules:
- type: "band1.hard.no_forbidden_succession"
pairs: [["Night", "Early"], ["Late", "Early"]]
- type: "band1.hard.coverage_floor"
enforce: strict
- type: "band3.soft.complete_weekends"
weight: 30
- type: "band3.soft.fairness_spread"
max_allowed_variance: 1.35
solver_options:
engine: "hybrid_rotation_tensor"
hardware: "gpu_accelerated"
emit_certificate: true# Invoke Helixor Solver via Python SDK / REST Client
from helixor_solver import HelixorSolverClient, ProblemPayload
client = HelixorSolverClient(api_url="https://api.helixor.ai/v1", api_key="hx_live_...")
payload = ProblemPayload(
manifest_path="./roster_manifest.yaml",
dataset="hospital_ward_b_august",
timeout_seconds=45
)
# Execute solve with fail-closed diagnostics
result = client.solve(payload)
if result.status == "FEASIBLE_CERTIFIED":
print(f"Solved in {result.metrics.latency_ms}ms")
print(f"Hard Violations: {result.certificate.band1_hard_violations}") # Strictly 0
print(f"Proof Hash: {result.certificate.proof_hash}")
result.save_schedule("approved_schedule.json")
else:
print(f"Solve Held: {result.failure_code} — {result.hint}"){
"status": "FEASIBLE_CERTIFIED",
"lexicographic_verdict": {
"band0_eligibility_violations": 0,
"band1_hard_violations": 0,
"band2_unplaced_slots": 0,
"band3_soft_penalties": 2320,
"band4_cost_objective": 48950.00
},
"certificate_metadata": {
"engine_version": "helixor-tcn-2.4",
"dual_scorer_confirmed": true,
"audit_depth": "exhaustive",
"proof_hash": "sha256:7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069"
},
"diagnostics": {
"fairness_spread_achieved": 1.32,
"weekend_adherence_percent": 98.4
}
}# Model Context Protocol (MCP) — solver.solve Schema
{
"name": "solver.solve",
"description": "Run a Helixor solver against the solver server. Omit problem_type to list available manifests. Pass dataset='demo' only for local demonstration data. The server never fabricates solutions: missing inputs return a typed failure envelope with repair hints.",
"parameters": {
"type": "object",
"properties": {
"problem_type": { "type": "string", "enum": ["nurse_rostering", "vrp_routing", "allocation", "batching"] },
"dataset": { "type": "string" },
"manifest_override": { "type": "object" }
},
"required": ["problem_type"]
}
}Get Started With Helixor Solver
Bring one problem. We will map the rest.
Start with one scheduling, routing, allocation, or disruption recovery problem that matters today. We will configure the declarative manifest, constraint contracts, and 5-band legality checks needed to put it into production safely.