Skip to content

AI engineer, designer, implementer · St. Paul, Minnesota

About

AI, Software, Design Engineer.

Kartik Jevaji, AI engineer, designer, implementer

Ontomancer is the word I use for the first half of the job: work out what the entities in a domain actually are, how they relate, and what has to be true — then generate as much of the system from that as possible. The second half is building it. I do both, and the design in between.

In practice that means a TypeDB ontology compiled into a Rust type layer, hand-written numerics on top of it, and a Kani proof suite establishing the invariants that tests can only sample. It also means fine-tuned small models with the evaluation harnesses to say whether they actually improved, agentic and domain ontologies for symbolic grounding, and the front-end and infrastructure to ship any of it — wireframe through to production deploy, including the four themes on this site.

The route here was not straight. A master's in statistics, then Epic from 2011 to 2013 — coordinating a hospital rollout in Omaha across five analysts, and taking the customer's first phone call when something broke. A long way around after that, and years of volunteering with the Alzheimer's Association alongside it.

The thread through the work I choose is cognition: a mental-health check-in app, a cross-platform tool implementing the NASA Task Load Index for cognitive load, retrieval over municipal code so a resident can find the permit checklist without reading the ordinance. Proof where proof is possible. Evaluation everywhere else. Neither one is optional.

Things I work on

Proof, not sampling

Formal verification

Model checking establishes properties over all inputs in a bounded space. A test tells you about the cases you thought of.

  • Kani proof harnesses over the numeric kernels of a statistical computing library — index bounds, totality, structural invariants like bijectivity and partitioning.
  • Miri as the dynamic undefined-behaviour backstop for what model checking cannot reach.
  • Quality gates that lock invariants mechanically rather than by convention: a test that requires a written SAFETY justification for any future `unsafe`, in a codebase that currently contains none.
  • Reading and tracking the wider ecosystem — Creusot, Verus, Charon, Aeneas, Dafny, and the verified Rust standard library effort.

Measure what you cannot prove

AI security & evaluation

Language models are probabilistic. Where proof does not apply, the answer is graded evaluation, determinism, and adversarial testing.

  • Harness-level evaluation frameworks with graders for accuracy and hallucination detection, integrated with LangSmith and MCP.
  • Deterministic agent interfaces — reproducibility treated as a product property rather than a debugging aid.
  • Benchmark construction and repair: rebuilding a code-generation benchmark, then measuring a fine-tune against it.
  • Security review as practice — hardened deployments, database security audits, and the AI security verification standards.

Structure a reasoner can traverse

Symbolic grounding

Formal schemas turn tacit domain knowledge into something a reasoner can walk and a model can be held accountable to.

  • A TypeDB ontology as the single source of truth for a Rust type system, compiled to traits and structs by a zero-dependency generator.
  • Agentic and domain ontologies backing a symbolic verifier loop.
  • Abstract entities become marker traits with the hierarchy preserved; concrete entities become structs carrying every inherited attribute.
  • Knowledge representation tooling — TypeQL, LinkML, Datalog stores, and semantic web frameworks.

The loop is the product

Agents, workflows & harnesses

An agent is easy to demo and hard to trust. The interesting engineering is the harness around it — what it is allowed to do, what grades it, and whether the same input twice gives the same answer.

  • Multi-agent architectures on the OpenAI Agents SDK with agentic memory and caching, against Azure OpenAI, driving an A2UI surface.
  • Harness-level evaluation frameworks with graders, adopted internally by QA — the thing that says whether a change to a prompt or a model actually improved anything.
  • A reasoning loop with a symbolic verifier, checking generated output against agentic and domain ontologies rather than against a second model's opinion.
  • Contract-first workflow orchestration: deterministic pipelines, generated configuration, and tests over the orchestration itself.
  • MCP integrations and LangChain/LangSmith tracing, with determinism treated as a product property rather than a debugging aid.

Corpora nobody has built yet

Data mining

Fine-tuning a model for a domain means first having the data for it, and for the domains I care about that data does not exist in a convenient form. So I go and build it.

  • A continuously running pipeline streaming merged pull requests from the public GitHub Archive, enriched with diffs, reviews, and commits, exported as JSONL training sets — deduplicated on event ID, with language-specific subsets refreshed on a schedule.
  • Synthetic data generation for domains with almost no public corpus: COBOL, and CMS Pricer systems.
  • Parsing CMS hospital price transparency filings — public data published in formats that resist being read.
  • Retrieval corpora built from primary sources, like a city's municipal code, so an answer can cite the ordinance instead of recalling it.

Wireframe through to deploy

Platforms & full stack

The verification work only matters if the thing ships. I build the whole path — schema, API, interface, pipeline, host — and I have run it in production for paying customers.

  • A federated multi-tenant platform serving several brands from one codebase, with contract-first internal packages and an ontology-backed data layer.
  • Migrated a company site from WordPress to React/Next.js, taking Lighthouse from 60–80% to 99–100% and reaching top-10 search rankings.
  • CI/CD with weekly deployments and a 300+ test Playwright suite.
  • Infrastructure as code — Ansible across VPS hosts, nginx, systemd, containerised services, error tracking.
  • Cross-platform delivery: web, iOS, and Android from a shared codebase.

Elsewhere

GitHubLinkedInHugging FaceEmail

Also: experience, education, and skills.