Leharaditya Kumar

PetaSight is a small company with a wide brief: a portfolio of products and proofs of concept, with a special emphasis on medtech. I came in as the founding engineer right after it acquired Babbage Insight, where I had been working, and the first job was the ground under everything else — multi-account AWS on Terraform and OpenTofu across the product verticals, a zero-trust, least-privilege IAM model, key rotation through Secrets Manager. ECS Fargate for compute, RDS for data, one VPC per account.

The first app we took all the way to a product is MyT+, an AI mental-wellness companion built on custom fine-tuned Bedrock models. I worked on it end to end: the backend and the agents behind it, the cross-platform build with Capacitor, App Store review, and the encryption — multi-party end-to-end, X25519 and AES-256-GCM, with keys generated in the browser so a conversation between a person and the model is unreadable to anyone else, including us. Alongside the app I helped build a robust training pipeline: PyTorch and PEFT fine-tuning LoRA adapters that deploy straight into Bedrock, and a streamlined loop for shaping the agents' tone and techniques.

The other products are earlier in their lives, and on those I work directly with the clients — understanding what they actually need, building the proof of concept, and turning the ones that land into something that ships. Under most of them sits the same foundation: an agent harness on Mastra with context-window management, memory and tool calling, and a Model Context Protocol server of about forty tools with OAuth 2.1 PKCE and dynamic client registration, so the products can be driven straight from Claude, Cursor and VS Code.

The piece I'm proudest of came out of a review problem. I was building a custom PR-review agent, and every product here is a multi-repo setup — a change in one repo can quietly break app integrity in another, which the usual review tools never see, because they assume one consolidated repo. So I built an internal graph knowledge base that maps the code across repositories, and the review agent reasons over that graph rather than over a single diff. On the same questions, same repos and same model, the graph roughly tripled what the agent got right — from almost nothing asserted correctly to about 80% — with zero hallucinations, for a small bump in cost.

What I'm building now is quoting software: a request to quote currently takes around 48 hours to turn around, and the goal is 30 minutes.

And the plumbing that keeps all of it honest: a CI/CD pipeline for the company's infrastructure on GitHub Actions with OIDC and AWS CodeBuild, with testing gates before anything reaches production.

Babbage Insight built an insights engine, and a lot of my time went into getting it running on other people's data. I worked directly with enterprise clients to understand what they had, then built the proofs of concept that ingested, processed and executed the Insight Engine on their live environments. That work is what turned conversations into contracts.

Search over the core insights repository became a hybrid pipeline — keywords, BM25 and vector reranking together — so a query found the insight that mattered rather than the one that happened to share a word with it.

Reporting was the other half. I re-architected the frontend data-visualization layers so that complex web-dashboard states convert into dynamic, highly optimized email report templates, and engineered the automated delivery of those reports: an asynchronous pipeline on AWS EventBridge and Amazon SES that parses the post-engine analytics and streams targeted results to the right stakeholders.

Superjoin lives in the space between spreadsheets and real data systems, and I got in through a side project in exactly that space: Sheet Saga, a tool that keeps a Google Sheet and a Postgres database in sync, with a change log of everything that moved. I built it on Supabase, and it is still up.

Once in, I worked on the Sheets Copilot and the data infrastructure around it. I developed the Snowflake connector, with custom RSA key-pair authentication so data in transit to Google Sheets stays zero-trust encrypted, and helped modernize the existing Salesforce connector.

I built the company's monitoring: a distributed observability stack on Prometheus, Grafana and OpenTelemetry that made incidents traceable, so problems were found and fixed faster. I also built the evaluation framework used to validate and tune the Copilot's inference backend and bring its latency down, and designed the internal tooling for tracking and reporting client interactions.