80+ products in production at UnitedHealth Group. Six flagships and 55 more documented here. I architected the initial versions of the six and scaled them with my teams.
Healthcare operations run on thousands of repetitive desktop and web tasks.
The decision. Retire the licensed automation estate and own the engine, rather than renew an eight-figure contract and keep paying per bot.
When an AI agent writes code, something has to run it.
The decision. Build the execution boundary inside the enterprise perimeter, rather than route model-written code to a hosted execution service.
Prior authorization is the highest-volume decision a health plan makes: dense with policy rules, mostly tabular, and unforgiving on turnaround time.
The decision. Train a small, inspectable model for the highest-volume decision, rather than route it through a frontier model or accept ensembles that cannot show their reasoning.
Each line of business was building its own analysis, forecasting and outreach automation from first principles, with no shared memory, no shared safeguards and no way to reuse what worked.
The decision. Give every line of business one shared agent framework with common memory and safeguards, rather than fund parallel builds.
Financial institutions have adopted AI broadly and kept autonomy rare, because nobody can show a supervisor what an agent would have done to the book, the controls or the customer.
The decision. Make the audit trail and the capability the same system, so an agent's decisions are rehearsed and evidenced before they touch the real book.
Datacentre dashboards report what is happening.
The decision. Model the datacentre as a system that can be asked what happens next, rather than a dashboard that reports what happened.
55 more, by capability. Open a row for the problem, the decision and the build.
Enterprise automation · Enterprise platforms
One governed runtime where business workflows and AI agents are steps in the same graph.
TypeScript, Node.js, Vue 3, PostgreSQL, TypeORM, Redis, Socket.IO, Azure OpenAI
Enterprises run automation in one tool and AI agents in another, with no shared execution engine, credential store, access model or execution trace.
The moment an agent writes to a system of record, the automation platform's governance becomes the agent's governance. Splitting them across two runtimes doubles the control surface and halves the visibility.
Orchestra is a self-hosted control plane where a team draws a workflow on a canvas and attaches an agent hierarchy to any step that needs judgement rather than a rule. The engine executes node graphs with explicit state, concurrency limits and a scheduler, over a node set covering HTTP, databases, files, email, branching, loops and webhooks. Agents sit in three nested coordination tiers over a message bus and a shared blackboard, with one provider abstraction in front of the models. Identity, role-based access, encrypted credentials wired to enterprise vaults, live execution streaming and tracing are part of the runtime rather than additions to it.
Built by the team I led alongside CRYO, 21 engineers with 18 indirect, under the AI/ML Review Board I chaired.
Defense and national security · Enterprise platforms
Live detection and tracking of objects across satellite and surveillance feeds.
Python, Computer vision, Neural networks, Satellite imagery, Real-time systems, GIS
Analysts watching satellite and surveillance imagery had to derive an object's speed, orientation and properties by hand, which does not scale to a live feed.
Intelligence value decays by the minute. Detection that arrives after the window has closed is an archive, not a decision.
I engineered object-tracking neural networks for remote-sensing imagery, autonomous aircraft and reconnaissance systems, and stood up the on-site infrastructure carrying live image feeds from satellites and surveillance cameras into them. The system derives an object's speed, orientation and physical properties frame by frame, so an analyst reviews conclusions rather than pixels.
Healthcare claims operations · Agentic systems
Agents that read the governing procedures and adjudicate a claim in under a minute.
Python, LLMs, NLP, Document processing, CRYO, FastAPI
Claims adjudication depends on long standard operating procedure documents that change often. Reading them, applying them and documenting the result took an adjudicator around ten minutes per claim.
Claim turnaround is what providers and members actually feel. Cutting it by an order of magnitude changes cost per claim and experience at the same time.
Built on CRYO, the system parses the governing procedure documents, extracts the rules applicable to the claim in hand, and runs an agent team that gathers the evidence, applies those rules in order, and writes a decision with its reasoning attached. Cases that fall outside a clear rule route to a person with the analysis already done rather than being pushed through. It runs at production volume every month.
Delivered by the AI organization I led, 21 engineers and 18 indirect, against a multi-million dollar budget.
Applied research automation · Agentic systems
A long-horizon agent that proposes, tests and refines solutions, and remembers what worked.
Python, Pydantic, ChromaDB, NetworkX, Typer, structlog
A single model call cannot carry a research or optimization effort. There is no structured hypothesis generation, no systematic search over candidates, and nothing carried between runs.
The expensive work in an enterprise is rarely one answer. It is a hundred iterations against an evaluation function, and the organization forgets almost all of them.
The engine runs a closed loop of generation, verification and evolution. A generator turns an objective into hypotheses and a task graph, a verifier searches a solution graph under an upper-confidence-bound policy to refine candidates, and an evolver writes outcomes back into memory. Memory is split three ways, strategy and procedure, task episodes, and semantic knowledge, all held in a vector store so the next run starts from what the last one learned. Model providers and vector stores are pluggable, so it sits behind an organization's existing gateway.
AI platform · Agentic systems
Memory hierarchy that lets an agent work for days without drowning in its own transcript.
Python, Pydantic, NumPy, tiktoken, Vector retrieval
Agents working multi-hour tasks fill their context with raw execution traces, and nothing they learn survives into the next task.
Long-horizon autonomy is a memory problem before it is a model problem. Paying to resend a growing transcript is the most expensive way to forget.
CogniCache gives an agent three tiers. The first holds raw events, code changes and terminal output for the phase in progress. When a phase closes it is distilled into a knowledge unit carrying the judgments, insights and progress that matter, and when a task closes those units are distilled again into a durable record stored with an embedding. A new task begins by embedding its descriptor and retrieving prior records above a similarity threshold, so an agent organization accumulates institutional memory instead of restarting.
AI platform · Agentic systems
An org chart for agents: workers, coordinators and system tiers with a bounded span of control.
Python, Pydantic, LangGraph, FastAPI, ChromaDB, OpenTelemetry, Kafka, MCP
Flat agent frameworks lose coherence past a handful of agents. Coordination turns into noise, one failure takes the run with it, and nobody can say which agent did what.
Enterprises do not deploy three agents, they deploy hundreds. Scale needs the answer organizations already use for people: a small span of control at every level.
Agents compose into command hierarchies. Workers do the task, coordinators decompose and delegate to a small set of direct reports and aggregate results over a shared blackboard, and higher tiers coordinate coordinators, each talking only to adjacent levels so a failure stays inside its branch. A fluent builder and a configuration loader are the two ways to declare a system. Provider adapters cover Azure OpenAI, OpenAI, Anthropic, Gemini, Cohere and local models, messaging runs in process or over NATS or Kafka, and a governance module handles policy, personal-data redaction and content filtering with red-team testing and distributed tracing alongside.
Life sciences · Agentic systems
Seven agents reconcile three authoritative registries into one sourced, scored answer.
Python, asyncio, httpx, Pydantic, Typer, BeautifulSoup
Answering a genomics question means querying several authoritative registries whose records disagree and whose payloads are too large and too irregular for one prompt to parse reliably.
The pattern generalises well beyond genomics. Any question spanning several systems of record has the same shape: plan the calls, cope with payloads no template anticipated, and reconcile conflicting sources into an answer someone can audit.
A task-detection agent classifies the question, a coordinator asks the model for a plan of concrete registry calls and fires them concurrently, and a response handler parses the returns. A feature extractor summarizes schemas too large to prompt with, a code-writing agent generates extraction logic for the payload actually in front of it, and an executor runs that logic in a restricted environment. A final decision agent reconciles the sources into an answer carrying its confidence, the sources used, and the call and token cost of producing it.
Autonomous systems · Agentic systems
One plain instruction becomes a verified, parallel, fault-tolerant plan across a mixed fleet.
Python, py-trees, PDDL, NetworkX, Pydantic, Jinja2
A goal stated in plain language has to become a formally correct, conflict-free schedule across several machines with different capabilities, and then survive failures during execution.
A model alone writes plans that cannot run. A classical planner alone cannot read intent or allocate work. Enterprises need both, with the verification step non-negotiable.
Three stages cascade. A model decomposes the instruction into subtasks, allocates them by capability, and emits formal planning problems against a written domain. A classical planner solves each subproblem by search, and the model then merges the sub-plans, resolves conflicts and inserts synchronisation points. The merged plan compiles into a parallel behavior tree where every action is wrapped in preconditions, validation, retries and fallback recovery, so no step executes on trust, with a shared blackboard carrying cross-agent state and sync signals.
Knowledge discovery · Agentic systems
An agent that decides when to broaden the search and when to follow the citation trail.
Python, PyTorch, asyncio, Pydantic, httpx, Rich
Conventional search runs a fixed pipeline of one query and one ranked list. It misses everything reachable only through a citation chain and wastes effort re-running near-duplicate queries.
In regulatory filings, clinical evidence, prior art and claims files, the document that matters is usually two hops from the obvious query. Deciding when to broaden and when to deepen is the work.
The agent holds a pool of accumulated documents with relevance scores and expansion flags, renders a partial view of that pool and its action history into a prompt, and chooses each turn between issuing a new query and expanding a document's references. New results are scored for relevance and folded back into the pool. A policy optimizer treats the whole multi-turn trajectory as the unit of credit, with a reward combining relevance gain against a penalty for repeating itself.
Autonomous systems · Models and applied research
Learned multipath routing so an aircraft fleet keeps its urgent traffic moving.
Python, PyTorch, Gymnasium, NumPy
In an aircraft mesh network every link is temporary. Aircraft move at tens of metres per second, line of sight comes and goes, and single-path routing collapses under load and misses deadlines for urgent traffic.
Inspection fleets, disaster response, logistics corridors and reconnaissance all depend on connectivity no fixed network provides. Deadline-critical packets cannot wait for a route to recover.
Routing is treated as a decentralised control problem. Each aircraft decides, from what it can locally observe, what fraction of its queue to send to each reachable neighbour, so the action is a traffic split rather than a single next hop. Independent policy optimization trains every aircraft on shared weights, a recurrent encoder handles a neighbour set that changes shape, and a sparse activation pushes the split onto a few real paths. The training environment models three-dimensional mobility, line-of-sight and signal-to-noise channel behavior, and per-aircraft priority queues with deadlines, with three classical routing strategies running in the same harness as comparators.
Scientific and risk modeling · Models and applied research
Predictions routed through named physical quantities, so every number can be traced back.
Python, PyTorch, NumPy, SciPy, scikit-learn, pandas
A standard deep model learns an arbitrary mapping from input to answer, which cannot be audited. Concept-bottleneck approaches fix that but need complete input, concept and target tuples that real observation data never has.
In carbon reporting, catastrophe pricing and yield forecasting, a regulator or an actuary has to see why a number moved. An unauditable estimate is worth less than a slightly less accurate one that can be defended.
Multi-modal encoders feed per-concept sub-models that each predict a named physical quantity, and an aggregator combines those interpretable intermediates into the final answer through an attention, process-guided or allometric relationship. A two-stage trainer pre-trains each concept on whatever data source covers it, then fine-tunes end to end, which is what makes heterogeneous and non-overlapping supervision workable. Output is quantile-regressed, so every estimate carries calibrated uncertainty bands into downstream risk logic, with monotonicity, spatial consistency and bias terms layered on the quantile objective.
Model risk and reliability · Models and applied research
Measurable lift on a frozen production model without reopening its approval.
Python, scikit-learn, XGBoost, Optuna, NumPy, pandas
Production models cannot always be retrained. They are validated, governed, or embedded in systems where changing weights is expensive or forbidden, yet they underperform in specific slices of the input space.
The people who would block a retrain are the same people who need the model to improve. A correction layer they can read is the only version of this they will approve.
BoostPatch leaves the model untouched. It computes residuals, fits a shallow tree on absolute error to isolate the regions where the model is worst, then runs a two-level loop in each region: a language model drafts a small correction function in plain Python, and Bayesian search tunes its thresholds and coefficients, keeping the correction only if the metric improves. A learned gate weighs each correction against the base prediction. Model calls happen only at build time, so inference stays plain Python and every correction is source code a governance function can read line by line.
Applied AI research · Models and applied research
Agents that learn concepts separately, then describe combinations they have never seen.
Python, PyTorch, torchvision, NumPy, SciPy, scikit-learn
Neural systems generalise poorly to new combinations of familiar concepts. An agent that has learned red and triangle separately usually cannot describe a red triangle it was never trained on.
Every large AI program eventually meets this wall: the system handles the combinations it was trained on and fails on the ones it was not. Fixing it upstream is cheaper than papering over it downstream.
Two cooperating agents share a discrete codebook that acts as their vocabulary. Training runs in two phases, first decompose, where single concepts are learned into codebook entries, then compose, where those entries are combined into phrases describing objects held out of training. A sender encodes an object into codebook words and a receiver scores candidates against the message received, with the codebook maintained by moving averages and reinitialisation of unused entries. Five formal compositionality metrics ship alongside, so the generalisation claim is measured rather than asserted.
AI platform · Models and applied research
Spend inference compute where the model is uncertain, not on every question equally.
Python, PyTorch, Pydantic, httpx, Typer, NumPy
Accuracy at inference time is usually bought with brute-force parallel sampling, which spends the same very large token budget on easy and hard questions alike.
Someone owns the inference bill. Adaptive compute is the difference between an assistant that is affordable at enterprise volume and one that is not.
The controller reads the model's own token-level confidence from its log probabilities and compresses it into a fixed feature vector. A very small convolutional policy network then decides, per response, whether to halt, ask the model to rethink, or take a different approach entirely, and the refinement loop repeats generate, extract and decide until it halts. The controller is trained supervised on labelled refinement trajectories. It is model agnostic across any endpoint returning log probabilities, and the action set is extensible, so a regulated business can add an explicit refuse and escalate decision on low-confidence answers.
Financial crime and trust · Models and applied research
Scores groups of connected accounts, so collusion shows up where single accounts look clean.
Python, PyTorch, PyTorch Geometric, scikit-learn, NumPy, PyYAML
Conventional detection scores accounts and transactions in isolation, so collusive behavior stays invisible because no single member looks unusual. Confirmed examples of such rings are also extremely scarce.
Organised fraud is where the loss concentrates and it is the hardest thing to label. A detector that needs ten examples rather than ten thousand is the difference between catching a new pattern this quarter or next year.
A feature-deviation graph network produces node embeddings, an estimator extracts the high-scoring groups inside each subgraph, and a two-level contrastive objective pretrains the whole model without labels at both subgraph and node level. Adaptation to a new fraud pattern then uses as few as ten labelled subgraphs, with each node's score refined by its nearest neighbours through a bilinear context scorer and a loss weighted by the proportion of anomalies. Parameter constraints during adaptation preserve what pretraining learned.
AI platform · Models and applied research
Teaches a model to make its best answer its default answer.
Python, Pydantic, Typer, httpx, NumPy, loguru
Standard post-training optimizes a model's single-shot output, so the model never learns from its own strongest attempt. The gap between what it can produce and what it does produce stays open.
Most enterprise quality problems are not capability problems. The model can already answer well some of the time, and closing that variance is cheaper than a larger model.
The loop runs in two stages. It samples several drafts per prompt, scores each with a reward function the team defines, and keeps the best. It then rebuilds the prompt with that best draft attached as an initial attempt, samples refinements, and normalises the rewards within the group to produce advantages. A clipped surrogate objective with a divergence penalty keeps the update stable, and the reward interface is the integration point: swap a generic grader for a domain grader, claim adjudication, coding policy or clinical summarization, and the loop is unchanged.
AI platform · Models and applied research
Change how a shared model behaves with a runtime dial instead of another fine-tune.
Python, PyTorch, Transformers, PEFT, Accelerate, NumPy
Aligning a large model normally means fine-tuning its weights, which is expensive, slow and impossible when the model is frozen, vendor-hosted or shared across many teams.
One model layer serves many business applications and each needs a different behavioral posture. Commissioning a fine-tune per policy does not scale and does not survive a model upgrade.
A small guide model is trained once on preference data and then steers the large model during decoding. Token-level rewards are extracted by running the frozen model under opposing behavioral prompts and scoring each token by the difference in likelihood. The guide is trained with a flow-conservation objective over token subtrajectories using low-rank adapters. At generation time the two distributions are blended with exponent weights, so alignment strength becomes a runtime parameter that can differ per application or per request while the large model's weights stay untouched.
Life sciences · Models and applied research
Turns a plain-language property specification into molecules that hit the numbers.
Python, RDKit, PyTorch, Transformers, FAISS, Pydantic
Generative chemistry can propose plausible molecules but struggles to land on several precise numeric property targets at once, which is exactly what a real specification asks for.
Computational chemists spend their time hand-tuning scaffolds to meet multi-property constraints. That work is search, and search is what machines do well.
Generation runs in two stages. The first reads a specification into a property target vector, retrieves reference molecules inside per-property tolerance windows, and runs an agent loop that decomposes a molecule into fragments and edits them with chemistry-toolkit property feedback after every change. The second runs multi-hop fragment edits scored by a weighted reward and ranked in groups, driving the residual error down, with a trainer that tunes the optimizer on a group's own compound collections rather than a general model.
Operations and risk · Models and applied research
Decisions that degrade gracefully when the data shifts, and explain themselves either way.
Python, PyTorch, NumPy, SciPy, scikit-learn
Predict-then-optimize pipelines break when deployment data drifts away from training data, and the robust alternatives are usually opaque.
A decision that is both robust and unexplainable cannot be signed off. Inventory, pricing, dosing and portfolio decisions all have a reviewer, and the reviewer needs the reasons.
The engine trains an ensemble of decision trees whose splits are smooth gates, which makes the whole forest differentiable end to end while keeping tree-style interpretability. Training happens against a worst-case version of the data distribution bounded by an optimal-transport distance that respects the causal link between drivers and outcomes, so the policy is tuned for shift rather than for the training sample. A specialized optimizer handles the nested expectation that objective creates. Global feature importance, per-case attribution and decision-path analysis come out of the model itself.
Automation and computer use · Models and applied research
Teaches a vision model to zoom in before it clicks, so dense interfaces stop breaking agents.
Python, PyTorch, Transformers, PEFT, Accelerate, Pillow
A computer-use agent normally sees one downscaled screenshot and has to click a small target from it, which fails on the dense interfaces enterprise work actually runs on.
Grounding accuracy is the ceiling on every automation built from a vision model. A single mis-click in a claims or billing interface is a real transaction gone wrong.
Inference runs in two stages. The model first reasons about the screen and decides whether to crop or zoom, choosing a center point and a crop size, and a toolkit executes that operation while tracking the coordinate transform. The model is then re-prompted on the focused region and its predicted click is projected back into original screen coordinates. Training uses a composite reward combining click accuracy, output format validity, and a tool reward blending crop-center proximity with target overlap, optimized by group-relative policy search over sampled trajectories.
Life sciences · Models and applied research
Three scientific views of a protein, with a router deciding how much each one counts.
Python, PyTorch, PyTorch Geometric, BioPython, NumPy, scikit-learn
A protein structure can be turned into a graph in many ways, and any single construction throws away signal: proximity misses chemistry, chemical similarity misses folding topology, energetic contacts miss local geometry.
Committing to one hand-picked graph bakes an assumption into every downstream prediction, and leaves scientists with no way to see which structural view actually drove an answer.
The engine builds three edge sets over residues at once: physical contacts from statistical potentials, chemical similarity from residue type and side-chain conformation, and geometric proximity by radius. Each view is encoded by its own edge-aware graph network, and a sparse mixture-of-experts router with top-k selection and a load-balancing term decides per protein how much each perspective contributes before a pooled classifier head. The router's weights come back with the prediction, so a scientist can see which view carried it.
Personalization · Models and applied research
Ranks on what an item looks like and says, not only on who clicked it.
Python, PyTorch, NumPy, SciPy, scikit-learn, PyYAML
Recommenders trained only on interaction history ignore what an item actually is, so cold starts are expensive and sparse catalogues stay sparse.
Every large catalogue has a long tail with no interaction signal at all. Content the model can see and read is the only way to rank it before the clicks arrive.
The engine learns from three signals at once. A heterogeneous graph convolution over the user and item graph produces collaborative embeddings, a recursive cross-modal attention block iteratively refines visual and textual item features against each other, and a nearest-neighbour item graph propagates semantic similarity. A contrastive objective aligns the collaborative and semantic views while a ranking loss trains the ordering, and top-k recommendation excludes items the user has already interacted with.
AI evaluation · Models and applied research
Scores the evidence a model cited, not only the answer it reached.
Python, Pydantic, NumPy, tiktoken, asyncio, Rich
In long-context question answering a model can reach the right answer from incomplete, wrong or entirely absent evidence, and an outcome-only score cannot tell the difference.
Where the citation trail is the deliverable, claims review, policy and contract questions, clinical and regulatory summaries, an unsupported answer is a compliance problem rather than a quality problem.
Every response is forced into four stages: analysis, evidence as verbatim quotes, reasoning, and answer. The total score blends output format, evidence quality and outcome correctness with explicit weights, and a judging step scores competing candidates comparatively rather than in isolation. A tree sampler explores alternative evidence sets and keeps the best-scoring branch, group-relative normalization turns those scores into advantages, and a co-evolution manager filters outcome-consistent runs to refine the scorer itself over time.
Autonomous systems · Models and applied research
Cheaper, steadier perception by training a policy on random halves of the scene.
Python, PyTorch, Transformers, NumPy, scikit-learn, OpenCV
Patch features from vision transformers are heavily redundant because attention mixes information across all tokens. Training a policy on that redundancy encourages memorising incidental correlations, and paying for every patch at inference is expensive.
Perception cost and behavior on unfamiliar conditions are the two things that decide whether a visual policy survives contact with the real world.
A selection module masks a configurable fraction of patch features on every forward pass, in three variants: zeroing dropped patches while preserving tensor shape, removing tokens entirely and adjusting position embeddings, and learning a per-patch drop probability. Around it sits a full training path with extractors over standard vision backbones, a policy head emitting control values, and a behavioral-cloning trainer. A redundancy analyser measures principal components, patch correlation and effective rank, so a team can check in advance whether their own features will benefit.
Healthcare operations · Models and applied research
Treatment recommendations tuned to the individual rather than the cohort average.
Python, Deep learning, CNNs and RNNs, Healthcare AI
Care pathways were optimized for cohorts, so individual variation in history, risk and response was left to be handled case by case.
Treatment optimization is where clinical outcome and cost meet. Getting the next best action right for one member is worth more than a marginal improvement in a population average.
I built a recommendation engine over member history and clinical signals that ranks care actions for the individual, trained on datasets engineered to mirror real-world statistical properties without carrying protected health information. It was deployed into care planning so the recommendations reach the people making the decision rather than a report.
Built with a team of six that I led and mentored on applied deep learning.
Healthcare operations · Models and applied research
Forecasts that make care planning proactive rather than reactive.
Python, TensorFlow, scikit-learn, Explainable AI, Healthcare compliance
Care planning relied on what had already happened to a member, so intervention arrived after the deterioration rather than before it.
The difference between a managed condition and an admission is usually a few weeks of warning. Prediction is the only way to buy that time at population scale.
I built predictive models over clinical and operational data that estimate a member's likely outcome trajectory, and put them where care planners work so accuracy improvements show up as better plans rather than better dashboards. The work ran under an explainability and model risk discipline, because a clinical audience will not act on a score it cannot interrogate.
Led a 12-person research and development team against a multi-million dollar budget.
Critical infrastructure · Models and applied research
Tells a genuine grid fault from a deliberate attack in complex-valued sensor streams.
Python, PennyLane, PyTorch, NumPy, scikit-learn, pandas
Phasor measurement streams on a transmission network are complex-valued and high-dimensional. Classical detectors flatten that structure and are brittle against deliberate manipulation, while quantum models that could encode phasors natively need impractical qubit counts at realistic feature sizes.
Utilities and industrial operators have to separate an equipment fault from an intrusion in minutes. Getting that wrong either way is expensive, and one way is dangerous.
The system partitions the sensor network into regional groups and gives each group its own small parameterised quantum circuit with amplitude encoding, rotation layers and entangling gates, which keeps qubit counts tractable and localises where an anomaly originates. Measured features are concatenated and classified by a compact classical head. A second variant adds calibrated classical and quantum noise to buy privacy on sensitive operational data and resistance to adversarial tampering, with attack harnesses and five classical and hybrid comparators in the same evaluation path.
Healthcare operations · Models and applied research
Inventory, distribution and scheduling optimized across healthcare facilities.
Python, Machine learning, Predictive analytics, Supply chain optimization
Healthcare facilities carried inventory and scheduled resources on rules of thumb, which produced shortages and waste at the same time and left patients waiting.
Supply chain is one of the few places in a health system where a model improvement converts directly into both lower cost and shorter waits.
I applied machine learning models to inventory and distribution across facilities, then integrated the forecasts into scheduling and resource allocation so the predictions changed what actually happened on the floor rather than what appeared in a report. The result was less resource wastage and shorter patient wait times.
Led a team of four engineers as lead engineer on the program.
Regulated language operations · Models and applied research
Finds the internal features that drive translation, then steers them away from invention.
Python, PyTorch, Transformers, safetensors, Pydantic, NumPy
Machine translation failures that matter, an invented dosage, a mistranslated legal term, a drifted language, are invisible at the output layer, so they get patched with prompts rather than fixed.
In clinical documentation, regulatory filings and compliance translation a wrong number is a liability. Judging output alone means finding out after it has been read.
A sparse autoencoder over the model's internal activations exposes individual features, and a three-stage discovery pipeline isolates the ones that actually initiate translation: frequency recall at key token positions, an influence vector measured by intervention, and a consistency filter. Those features become three controls: a steering hook that amplifies or ablates them during generation, a selector that picks fine-tuning data by feature activation and quality, and an audit signal that flags likely invented content, with quality and hallucination scoring in the same evaluation path.
Healthcare, medical and payer operations · Models and applied research
Reads a member's entire history, years of claims, encounters, labs, medications and authorizations, in one pass, with memory cost that grows gently rather than exploding with record length.
Hybrid state-space and attention sequence model
Risk and care models read a twelve-month window because full histories were too long for the model to hold, so the events that explain a patient were often outside the window.
The signal in healthcare is longitudinal. A model that reads a whole history sees the trajectory, not a snapshot, and one such model can serve many prediction programs at once.
I built a hybrid sequence model in which most layers carry a compressed running memory of the record and a few layers keep exact attention for the details that matter, so memory and cost grow gently with record length and the whole history fits on premises.
Healthcare, medical and payer operations · Models and applied research
One model whose internal experts specialize by line of business, claim type and region, so each case only pays for the parts of the model it needs.
Mixture of experts routed by line of business and claim type
Every line of business, claim type and region wanted its own model, and the enterprise ended up with dozens of models to build, validate, govern and retrain.
Specialization is right, sprawl is not. One model whose internal experts specialize keeps the accuracy of many models and the governance burden of one.
I built a mixture-of-experts claims model whose router sends each case to the few experts that fit its line of business and claim type, with experts retrainable one at a time and every routing decision logged for audit.
Healthcare, medical and payer operations · Models and applied research
Decides routine cases in a single pass and spends more internal reasoning steps only on ambiguous or high-value cases, with the depth it used recorded for audit.
Latent reasoning with learned halting, thinking longer only when a case is hard
Routine and complex cases were paying the same compute and the same latency, and the hard cases were the ones getting too little deliberation.
Compute should follow difficulty. The routine majority should be nearly free and instant, and the difficult minority should get more reasoning, with a record of how much it received.
I built an adjudication model that reasons internally in loops, with a learned signal that stops early on clear cases and continues on ambiguous ones, and paired it with a written rationale on anything escalated or denied so the extra depth is explainable.
Healthcare, medical and payer operations · Models and applied research
Reads claims interchange files, lab feeds, clinical messages, scanned forms and faxes at the byte level, so malformed segments and unusual layouts stop breaking the pipeline.
Byte-level and hierarchical tokenization for messy structured feeds
Intake pipelines broke every time a trading partner changed a format, a fax came in skewed or a message carried a segment the parser had never seen.
Healthcare data is delimiter-heavy, code-heavy and inconsistent. A model that reads raw bytes and learns its own chunking stops depending on the brittle parsers in front of it.
I built a byte-level ingestion model with a small local encoder that groups bytes into patches and a larger model that works on the patches, trained across interchange files, clinical messages, lab feeds and scanned forms, with constrained output so it never emits a malformed record.
Healthcare, medical and payer operations · Models and applied research
Generates determination letters, care summaries and member communications as a whole draft refined in parallel, inside templates and constraints that the output cannot leave.
Diffusion-style, non-autoregressive text generation under hard constraints
Determination letters, summaries and correspondence were generated word by word, which was slow at volume and let the text drift outside the template and the regulatory language.
Documents with a known shape should be drafted as a whole and refined, inside constraints the output cannot leave. That is faster, safer and easier to edit.
I built a diffusion-style drafting model that produces the entire document in parallel and refines it over a few passes, with template fields, required language and prohibited content enforced as hard constraints during generation rather than checked afterward.
Healthcare, medical and payer operations · Models and applied research
Learns one shared representation of a patient from every kind of record, so downstream programs stop building bespoke models for each data type.
Joint-embedding and predictive objectives across notes, images, labs and claims
Every program built its own model for its own data type, so notes, images, labs and claims each had a separate representation of the same patient and none of them agreed.
One learned representation of the patient, built from all record types without labels, is the asset every downstream model should share. It cuts build cost and the validation burden per model.
I built a multimodal clinical representation model trained with joint-embedding and predictive objectives, learning to predict the representation of the missing or future part of a record rather than its raw content, and exposed it as a shared backbone that new risk models fine-tune with a fraction of the labeled data.
Healthcare, medical and payer operations · Models and applied research
Adapts its behavior to a plan, a provider group or a region while it runs, from the cases in front of it, without a retraining cycle and without moving protected data.
Fast weights and test-time training, adapting at inference without retraining
Every new plan, provider group and region needed a retraining cycle, and retraining meant moving protected data and waiting a quarter.
Adaptation should happen at inference, from the cases in front of the model, without a retraining cycle and without protected data leaving its boundary.
I built a model with fast weights that update while it processes a case file, with strict state hygiene between members so nothing learned from one record carries into another, and reproducibility controls that record the state each decision was made under.
Healthcare, medical and payer operations · Models and applied research
Attends to a small learned subset of everything an agent has seen and keeps its working memory compressed, so multi-day care management and claims agents stay fast and affordable as their context grows.
Learned sparse attention and shared, compressed memory for long-running agents
Agents that work for days accumulate context until every step costs more than the last, and the enterprise ended up rationing the very agents that were saving the most work.
The binding constraint on production agents is memory during generation, not model size. An agent that learns what to remember can run all day at a flat cost.
I built an agent model that is trained to attend only to a learned, sparse subset of its history and to share and compress its working memory across layers, then distilled specialist versions of it small enough to run inside the data boundary.
Healthcare data security · Security and safety
Protected health data encrypted at the field level, so teams can build without exposure.
Python, Privacy-preserving ML, Encryption, Healthcare compliance
Every experiment on real healthcare data touches protected health information, so teams either waited for approvals or worked with data too thin to be useful.
Privacy controls are usually described as a brake on delivery. Built properly they are the accelerator, because they are what lets twenty teams work in parallel instead of queueing behind one approval.
I built privacy-preserving frameworks with field-level encryption of protected health and personally identifiable information, so datasets could move into experimentation environments with the sensitive attributes protected rather than stripped out. The work ran alongside the enterprise compliance program covering SOC 2 Type II, ISO 27001 and GDPR, and it was paired with model risk management frameworks so what teams built on that data stayed governed.
Built inside the research and development organization I led, twelve engineers against a multi-million dollar budget.
AI platform security · Security and safety
Stops a jailbroken answer mid-sentence, using the model's own safety awareness.
Python, PyTorch, Transformers, PEFT, Accelerate, NumPy
Prompt injection and jailbreak attacks get aligned models to emit content they were built to refuse. Input filters miss the attack, and classifiers applied afterwards only catch it once the unsafe answer already exists.
The team owning a shared model gateway is accountable when a crafted prompt gets a production assistant to say something disallowed. Catching it after generation is already too late to count as a control.
The insight is that even a jailbroken model retains safety awareness while it is still decoding. SafeProbe appends a trigger phrase and a safety clause to the conversation so far and measures how readily the model would continue with that clause. A low score means the model itself finds the disclaimer a natural continuation, which is the signal that it recognizes its own output as harmful. The probe runs at a random subset of decoding steps and aborts generation the moment the score crosses a threshold, and because probing can run on a small separately tuned model alongside the large one serving customers, the control does not degrade answer quality.
Model risk and security · Security and safety
Red-teams a classifier with its own explanations, where gradient attacks come up empty.
Python, PyTorch, SHAP, torchvision, NumPy, Matplotlib
Standard adversarial attacks use only the sign of the loss gradient, so they lose potency where gradients are masked or misleading. Teams are then unable to measure honestly how brittle a deployed classifier really is.
A robustness number is what a model risk file needs before a classifier goes in front of customers. An attack that fails is not evidence that a model is safe.
The engine computes attributions for an input, selects the pixels whose attribution magnitude exceeds a threshold, and shifts exactly those pixels toward a low-influence range scaled by a perturbation budget, rather than stepping by gradient sign. Classical gradient attacks run alongside as comparators. One interface runs a single attack, compares methods on one input, or benchmarks across a held-out set, returning success rate, perturbation norms and confidence drop as the evidence a review board can file.
Healthcare operations, end to end · Digital twins and simulation
A live, simulated copy of the whole healthcare operation, where decisions are rehearsed before they are real.
Process mining, Discrete-event simulation, Agent-based modeling, Causal inference, Synthetic data, Stream processing
Every consequential change in a health enterprise, a policy threshold, a network contract, a staffing plan, an automation rollout, a new AI system, was tested for the first time on real members, real providers and real money.
A payer or provider runs hundreds of interlocking processes. Changing one without seeing the others move is how savings in one department become costs in another. Leaders needed a place to rehearse.
I built a twin of the enterprise rather than of a single process: an event fabric that joins claims, authorizations, care management, pharmacy, contact center, revenue cycle and clinical operations into one time-ordered stream, process mining that reconstructs how work actually flows, a simulation engine in which members, providers, staff, bots and AI systems are agents with their own behavior, a causal engine that returns counterfactual ranges rather than single numbers, a synthetic population layer so no protected health information circulates, continuous calibration against live telemetry with drift alarms, and a decision desk where executives run scenarios and sign off the ones that move to production.
Owned end to end, from the research design to the executive decision desk, with the AI/ML Review Board's criteria gating every scenario that reaches production.
The value is the experiments that never had to run on real members, real providers and real money: policy changes tried at every setting, automation rolled out to the twin before the floor, staffing and network decisions made on evidence instead of instinct, and every AI system on the roadmap measured in the twin before it earned a place in production.
Industrial and clinical operations · Digital twins and simulation
A twin that models, mirrors, predicts and then manages the asset itself.
Python, PyTorch, Pydantic, NumPy, SciPy, FastAPI
Classic digital twins are passive simulations: expensive solvers, no live link to the physical asset, and a person in the loop for every decision.
Organizations already run separate simulation, monitoring and decision-support stacks over the same asset. One lifecycle behind one interface is both cheaper and more truthful.
The framework defines four lifecycle stages, modeling, mirroring, intervening and autonomous, with components registered against each and forward-only transitions between them. The modeling layer uses physics-informed neural networks that embed the governing equations into the loss through automatic differentiation, so the twin stays physically plausible at a fraction of the compute a mesh solver needs. The autonomous layer wraps a language model in a monitor, analyze, plan and execute loop over the twin's state, which is what turns a simulation into something that can act.
Healthcare data · Digital twins and simulation
Faithful stand-in data and twins that let teams experiment without touching real records.
Python, TensorFlow, scikit-learn, Digital twins, Synthetic data generation
Experimentation on healthcare data is gated by privacy for good reason, and the queue for access is where most ideas died before they were ever tested.
Testing speed is the real constraint on an enterprise AI program. Removing the privacy blocker without weakening the privacy position is the highest-leverage thing a data organization can do.
I built synthetic data models that reproduce the statistical properties of real operational datasets, the correlations, distributions and edge behavior, without carrying any protected health information, and digital twin simulations that let teams run scenarios against a faithful stand-in for the live system. The output went to operational teams across the enterprise as a shared asset, which is what turned a technique into infrastructure.
Led the 12-person team that built it and ran the enablement that took it across the enterprise.
Emergency management · Digital twins and simulation
A live twin of a fire, matched against past events, with an intervention plan attached.
Python, Pydantic, NumPy, SciPy, FAISS, Typer
Wildfire response misses its first window because sensor, agency and responder data are fragmented, situational awareness updates slowly, and coordination stays reactive.
An incident commander needs a defensible recommendation in minutes. The alternative is a decision made on instinct that will be reviewed for years.
The platform maintains a twin of the fire environment that ingests sensor readings, tracks resources and logs every dispatched command. A spread simulator steps the fire forward under wind, terrain slope, humidity and fuel parameters. A scenario store holds past events indexed for vector search, so a similarity agent embeds the current situation and retrieves the closest historical matches above a threshold, and a reasoning agent turns the twin state and those matches into intervention recommendations with the reasoning attached.
Financial services · Data and retrieval
Learns how to augment training data so models hold up when the market regime turns.
Python, PyTorch, pandas, statsmodels, NumPy, scikit-learn
Markets drift, so models trained on historical data quietly lose accuracy out of sample. Naive augmentation of price series breaks financial validity, and fixed augmentation policies do not adapt as a model starts to overfit.
Model decay is a silent cost. It shows up as worse decisions long before anyone reruns the test that would have caught it.
A planner network reads the statistics of the data, volatility, momentum, skewness and trend, together with the model's own training state, and emits which transformations to apply and how hard. A scheduler adjusts intensity from validation feedback so augmentation rises as overfitting appears, and the two train jointly with the task model in a two-level loop. A curation layer enforces real market constraints on everything synthesized, valid price bars and cointegrated cross-asset partners, and quality checks score whether the synthetic data still reproduces the statistical signatures of the real thing.
Enterprise data · Data and retrieval
Ask the enterprise a question in plain language and get the answer from its own data.
Python, Semantic search, Knowledge graphs, Vector databases, LLMs, FastAPI
Business questions had to be translated into queries by people who understood both the question and the schema, so the answer arrived days after the decision was needed.
Decision speed is a competitive property. When hundreds of people can ask their own questions, the analytics team moves from answering to building.
I built a platform that resolves a plain-language question against semantic graphs of the enterprise's entities and their relationships, then retrieves across multi-modal data rather than a single warehouse table. Knowledge graphs and vector retrieval work together: the graph fixes what the terms mean, retrieval finds the evidence, and the answer comes back with its sources. It went out to hundreds of users across the business.
Scoped and funded directly with the business units, then delivered by the team I led under the AI/ML Review Board I chaired.
Enterprise marketing · Data and retrieval
Turns years of inconsistent campaign data into the segments the next campaign runs on.
Python, Clustering, NLP, Marketing analytics, LLMs
Enterprise marketing data arrives inconsistent, duplicated and spread across systems, so campaign strategy was set on intuition and last quarter's summary.
Campaign spend is committed before results exist. Better segmentation before the spend is worth more than better reporting after it.
I built an AI pipeline that cleans and reconciles enterprise marketing data, clusters audiences on behavior rather than declared attributes, and analyzes the resulting segments to drive campaign strategy. The output feeds campaign planning directly, so the analysis changes what gets sent rather than what gets reported.
Built by the team I led, with requirements and funding negotiated directly with the marketing organization.
Enterprise document intelligence · Data and retrieval
Builds a small, diverse, fully auditable context pack instead of the ten most similar chunks.
Python, BM25, tiktoken, pandas, pypdf, Pydantic
Standard similarity retrieval returns near-duplicate passages from one section, covers secondary facets of the question badly, wastes tokens, and cannot explain why any passage was chosen.
In regulated document work, why a passage was in the model's context is a question someone will eventually ask. Flat similarity has no answer to it.
Documents are chunked with their section structure intact, a candidate pool is retrieved by keyword, dense or hybrid search, and each candidate is rescored with a structural prior for its section plus keyword boosts and a length penalty. Selection is then a constrained greedy pass under three explicit gates: a global token budget, a cap on how much any one section may contribute, and an overlap threshold that rejects anything repeating what is already packed. Every accept and reject is recorded with its reason and can be exported for review.
AI governance · Governance and assurance
Manufactures ground truth, so you can prove an explanation is faithful and not just plausible.
Python, PyTorch, Transformers, sentence-transformers, Pydantic, Typer
Explanation methods claim a concept drove a prediction, but there is no ground truth to check them against, so a faithful explanation and a plausible-sounding one score exactly the same.
A model risk committee, a clinical reviewer or a regulator is being asked to trust a stated reason. Without a measurement, that trust rests on nothing.
The engine defines explicit causal graphs over named concepts with structural equations and noise, samples concept values, and has a model write text realising those concepts. Interventions are applied with do-calculus semantics, holding noise fixed and recomputing downstream nodes, then re-verbalised, which yields original and counterfactual text pairs whose true concept effect is known by construction. Metrics then score any explanation method against that known effect, and four matching explainers plus a counterfactual-generation explainer with four prompting strategies ship in the same harness.
AI governance · Governance and assurance
The review board, standards and risk controls every enterprise AI system passes through.
Responsible AI, Model risk management, HIPAA, GDPR, SOC 2 Type II, ISO 27001
AI work was arriving faster than any single approval path could absorb, with no shared architectural standard, no consistent risk assessment, and no forum where a model could be challenged before it reached production.
A Fortune 5 health enterprise cannot scale AI on goodwill. Without a governing body, every system negotiates its own controls and the organization carries risk it cannot see.
I founded and lead the AI/ML Review Board that governs enterprise AI, chairing the technical review every significant system passes. Around it I established architectural standards, responsible AI guidelines and model risk management frameworks, and contributed to the enterprise compliance program covering SOC 2 Type II, ISO 27001 and GDPR. The same body is where multi-year AI roadmaps are set against enterprise objectives and where vendor and partner decisions are tested.
Founding member and lead R&D judge of the AI/ML Review Board, and founding technical partner of Optum & UHG Ventures, working directly with executive sponsors on enterprise AI strategy.
Safety and assurance · Governance and assurance
Tells you which guarantees a controller can actually keep when the goals conflict.
Python, Binary decision diagrams, NetworkX, NumPy
Classical synthesis is all or nothing: a set of requirements is either realizable or it fails, with no answer about which subset could still be guaranteed. Enumerating every subset is exponential in the number of goals.
Requirements documents always conflict. An assurance function that can only hear unrealizable has no way to negotiate, and no defensible statement of what the deployed system actually promises.
Temporal-logic requirements are parsed, converted to automata by tableau construction and subset determinization, and composed into a symbolic game between environment-controlled and system-controlled variables. A single fixed-point computation then runs over both state variables and Boolean goal variables whose implication structure encodes the fact that any subset of a winning goal set also wins, so one pass returns the maximal combinations that can be guaranteed rather than an exponential sweep. A winning strategy can be extracted for each realizable set.
AI governance · Governance and assurance
Rules decide what an agent may do, the model decides how, and a guard checks the output.
Python, Pydantic, NetworkX, structlog, Typer
Agents carry their safety constraints inside prompts or reward signals, so there is no auditable reason why a given action was permitted or blocked.
Compliance and clinical review boards do not accept a decision they cannot contest. Separating the rule from the response is what makes a constraint inspectable and arguable.
A four-stage pipeline splits normative reasoning from the response itself. A moral module extracts grounded reasons from the situation and applies a defeasible rule theory with explicit priority ordering to derive the set of permitted action types. A decision module then asks the model for a concrete response inside those constraints, and a guard verifies the generated response against the matched action type with per-type checkers, blocking and re-prompting on violation. Every run returns the reasons that fired, the conflicts resolved, the compliance result and a human-readable justification trace.
Decision fairness · Governance and assurance
Gives every stakeholder a guaranteed equal share of an automated allocation decision.
Python, NumPy, SciPy, CVXPY
When several parties share one automated allocation decision, standard optimizers maximize the aggregate and let the largest party dominate. There is no ready way to guarantee each participant equal influence over the procedure itself.
Allocation decisions get contested on process, not on totals. A documented guarantee of equal voice is what makes the result defensible to the parties it affects and to an auditor.
The engine models the decision as a multi-agent allocation problem over a reward structure and solves it under three selectable objectives: procedural fairness, where each participant holds exactly an equal share of the probability mass on its preferred options, resolved as a convex program, plus equality and aggregate-welfare objectives as comparators. An online learner estimates rewards from observed outcomes and re-solves each round with confidence bounds and decaying exploration. A stability module checks whether any coalition could profitably break away, which is the test of whether the allocation will hold.
Developer tooling · Engineering tooling
An agentic coding assistant for engineering organizations standardized on Azure OpenAI.
Python, Azure OpenAI, Click, Rich, prompt-toolkit, MCP, asyncio, Pydantic
Engineering teams whose policy allows only Azure OpenAI had no agentic coding assistant, because the available terminal agents send source code to other vendors' endpoints.
Source code is the asset most tightly bound by vendor policy. If the agent cannot run inside the approved boundary, the productivity gain is unavailable to exactly the teams that need it most.
It runs the full agent loop, read, edit, run, test and fix, entirely against an enterprise's own Azure OpenAI deployment. An orchestrator drives a tool registry covering file editing with multi-file atomic changes, search, persistent shell sessions, version control, tests, linters, formatters and notebooks, with streaming output, session persistence and resume, hierarchical memory, and conversation compression for long runs. A permission manager offers graded modes from read-only and plan-only through to accepting edits, and an MCP client connects internal tool servers. A programmatic interface embeds the same agent in other systems.
Software delivery · Engineering tooling
Ten specialist agents turn a conversation into specifications an engineering team can build.
TypeScript, Next.js, React, Y.js CRDT, PostgreSQL, Clerk, Stripe, Azure OpenAI
Enterprise software still starts with inconsistent, untraceable specifications written in documents nobody validates, so the gap between intent and implementation is discovered during the build.
Most delivery overruns are specification failures found late. Moving the rigour to the front of the lifecycle is the cheapest correction available.
A product owner describes the problem conversationally, a quality checker scores the requirements against a recognized requirements standard, and ten role-specialized agents expand them into an architecture document, an engineering plan with task breakdown, a test and quality strategy, an operations specification, interface and data-science specifications, and an instruction file for downstream coding assistants. The whole team edits simultaneously through conflict-free real-time collaboration. Specifications do not stop at the document: they push into version control and create tracked issues, so requirements stay traceable to the work that implements them.
Reference versions of many of these are on my GitHub, if you want to look: github.com/YashSharmaa.
Executive roles, board and advisory work, venture diligence, speaking. I reply within 48 hours.
