I engineer compound systems that separate probabilistic reasoning from deterministic execution. Fifteen years across ML, LLMs, and agentic AI — building architectures that survive in high-liability clinical and enterprise environments.
We do not pass raw neural output directly to execution vectors. Our systems are split into two completely isolated environments that communicate only through strict structural compilers.
Intelligence requires constraints. We architect reasoning engines that creatively explore solution spaces, distilling neural output into strict deterministic execution graphs. The LLM is not the system — it is an untrusted guest operating within a pre-validated stochastic range, free to innovate but never free to execute.
Where open-weight SLMs and reasoning agents creatively explore non-linear solution spaces, run multi-agent debates, and generate candidate traces without production risk.
Converts raw text, medical telemetry, and time-series data (TimesFM) into initial embeddings.
Isolated agents running LangGraph cycle-states, fanning out to model hypothetical paths.
Separate Agent Infrastructure from Agent Theater
Learn More about The Planning-Rubicon →Enterprise autonomy requires absolute reliability. Every neural output is intercepted by a rigid state machine that strips linguistic variance and enforces mathematical invariants. Governance, validation, and recovery come first. Intelligence is earned — never assumed.
The absolute state platform. This rigid containment unit intercepts candidate graphs, strips away linguistic variance, and executes code via immutable transactional state lines.
Distills neural traces into strict mathematical DAGs, validating schema layout before runtime.
Applies non-negotiable clinical and business invariants. Catches and neutralizes hallucinations natively.
Executes transactional tasks through gRPC agents with cryptographic logging and telemetry tracing.
We classify systems by what must never happen. Each pattern is a control structure binding neural generation to strict deterministic verification.
A deterministic rules engine controls the workflow. Neural models handle bounded fuzzy-logic tasks, but the symbolic engine owns execution, veto, and fallback. There is no override.
Use cases: Clinical decision support, autonomous vehicles, grid balancing.
package clinical.oncology
default allow = false
veto[msg] {
input.patient.lvef < 50
input.regimen.cardiotoxic == true
msg := sprintf("CRITICAL VETO: LVEF %d%% < threshold 50%%", [input.patient.lvef])
}
A neural reasoner proposes a solution. An external ontology or graph verifies it. Violations trigger a self-correction feedback loop. Maximum iterations lead to a deterministic fallback.
Medical CoT alignment pipeline for google/MedGemma-4B-IT.
MATCH (d:Disease)-[:METASTASIZES_TO]->(target:Disease)
WHERE d.name = $primary
AND NOT EXISTS {
MATCH (source:Tissue)-[:ORIGINATES_FROM]->(d)
WHERE source.name IN $patient_history
}
RETURN d.name, target.name, confidence
Neural agents propose strategies. A compiled mathematical engine (Nash equilibrium solver, VCG auction mechanism) checks every proposal against formal invariants.
Architecturally redundant. The Nash engine mathematically outclasses it.
def compute_vcg_clearing(bids: dict[str, float]) -> tuple[str, float]:
"""Calculates VCG winner and clearing price (externality imposed)."""
sorted_bids = sorted(bids.items(), key=lambda x: x[1], reverse=True)
winner, winning_bid = sorted_bids[0]
second_price = sorted_bids[1][1] # VCG clearing payment
return winner, second_price
We do not claim academic taxonomy compliance. Our systems are engineering hybrids. Every pattern declares its verification level honestly.
| Level | What it means | Implementation |
|---|---|---|
| Unit Tests | Component-level correctness | pytest across all production repos |
| Property-based | Invariant verification across inputs | Nash: 49 tests for IR & bounds |
| Benchmarks | Standardized task performance | TimesFM/Chronos-2 aligned to M5 WAPE |
| Audit Trails | Immutable, cryptographically signed | Clinical: full trace committed to ledger |
Clinical Intelligence System with Deterministic Policy Enforcement
At its core, AXIOMIS is a deterministic state machine for clinical oncology. Treatment plans compile to Directed Acyclic Graphs (DAGs) prior to execution. Each node undergoes pre-flight clearance by Regula OPA policies. Neural model proposals are never executed directly—they require symbolic justification and policy clearance.
def execute_clinical_dag(fhir_bundle: dict) -> ExecutionResult:
dag = compile_fhir_to_dag(fhir_bundle)
for node in dag.nodes:
clearance = opa_engine.verify(node.context)
if not clearance.allowed:
return fallback_to_symbolic_override(node, clearance.veto_reason)
return dag.commit()
Open to technical advisory, multi-agent orchestrations, or enterprise neuro-symbolic engineering roles.