Akhil Bonthinayanivari

Problem: Autonomous agent systems often run into runaway token costs, unsafe tool execution, and erratic multi-step coordination across enterprise backends.

Build: Built a LangGraph supervisor-worker architecture with custom MCP servers, gVisor container isolation, context compaction, human approval gates, and rigorous evaluation suites.

Outcome: Token usage dropped 42% per trajectory while task completion across 500+ golden scenarios surged from 71% to 94.2% at sub-3 second P95 tool latency.

Problem: Drug interaction review is hard to scale because useful signals are spread across biomedical entities, relationships, and literature-style context.

Build: Modeled drugs and biological relationships as a knowledge graph, then used a GNN ranking flow with Claude-generated summaries for explainable results.

Outcome: A reviewer can move from interaction candidates to a readable rationale without manually traversing the graph.

Problem: Research workflows often stall between open-ended search, source triage, and producing a brief that is structured enough to act on.

Build: Built a React and Express app where the model runs web search and must save findings and timeline events through typed tool calls before submitting a Zod-validated brief.

Outcome: Cuts the path from question to usable research artifact while keeping the output easier to inspect than a raw chat response.

Problem: Agent demos end at a pass/fail score, which says nothing about which step broke, whether a fix regressed something else, or what a new safety policy would have prevented.

Build: Built a Python harness with typed tool contracts, sandboxed state, canary egress checks and prompt-injection scanning, plus SQLite run storage, an authenticated review console, trace comparison and offline policy replay.

Outcome: Every failure becomes an evidence capsule with a fingerprint, root cause and suggested control, and a candidate agent can be compared to its baseline case by case before release.

Problem: Engagement-only rankers collapse into popularity loops, and most recommender demos stop at an offline notebook with no serving, exploration or feedback path.

Build: Trained a content-aware two-tower model with hard negatives and FAISS retrieval, a multi-task ranker for completion, like and skip, then added creator and category diversity caps, LinUCB exploration with propensity logging, and idempotent online feedback.

Outcome: On the seeded evaluation set the model reaches 1.55x the recall of a most-popular baseline while covering 85% of the catalog, and the UI exposes those metrics next to the live feed.

Problem: General chat assistants answer interview questions with tutorials, so the useful part is buried and the answer takes too long to say.

Build: Wrote a mode-based system prompt with strict output formats, a FastAPI server that streams Claude responses over SSE with prompt caching, and a dependency-free UI with mode detection, a rehearse-aloud button and speak-time estimates.

Outcome: Each answer leads with the result, ranks issues by severity and ends with the likely follow-up; deterministic checks plus an LLM judge keep the prompt honest as it changes.

Problem: Most generative AI experiences stop at an unstructured chat response, making creative output difficult to reuse, compare, validate, or export.

Build: Built a Node.js and Express application around the OpenAI Responses API with Zod-validated artifact schemas, local persistence, deterministic demo data, and test coverage for generation failure modes.

Outcome: Transforms an open-ended problem into a repeatable, reviewable artifact dossier that can be saved, deduplicated, copied, and exported as Markdown or JSON.

Problem: Every LLM provider has divergent tool calling formats, schema definitions, and streaming protocols, forcing teams into vendor lock-in or fragile wrapper code.

Build: Engineered an extensible TypeScript toolkit that normalizes tool execution, schema definition, retries, and output streaming into a single predictable interface.

Outcome: Enables developers to swap models from cloud providers to local instances with zero downstream code changes, with full type safety.