Shreyas Jagannath

Senior AI Engineer — Lendable Operations Ltd

Jul 2026 — Sep 2026

• Context: Internal Engineering Teams (Cross-Org)
• Problem: Engineering data was scattered across incident.io, Jira, Datadog, GitHub and Backstage with no governed place to model it, and no unified view of how developer tooling was actually being used across the delivery lifecycle.
• Architecture: GitHub, Jira, Claude, and Codex telemetry pipelines feeding the AI Hub dashboard; incident.io, Jira, Datadog, GitHub and Backstage data modelled in Snowflake for governed stakeholder access; a scoped, auditable agent skill for agentic access to that data; the codebase indexed with my own Nexus-MCP server for agent work; a company-level engineering cycle-time model on the GitHub GraphQL API, attributing each PR to a team by backtracking historical contribution share, with a manager-facing deny-list correction loop; four reusable skills replacing the manual investigation behind every new feature spec; deployment on Terraform/Terragrunt, GitHub Actions CI/CD, and Argo CD, including Okta SCIM/OIDC authentication and admin/user group setup.
• Outcome: Shipped on the organisation's Terraform/Terragrunt, GitHub Actions CI/CD and Argo CD deployment stack, and set up Okta SCIM/OIDC authentication with admin/user group management for the tooling I built. Modelled incident.io, Jira, Datadog, GitHub and Backstage data into governed, OKR-level Snowflake metrics leadership could act on. Gave engineers agentic access to governed data through a scoped, auditable agent skill rather than an MCP server, to meet FCA security requirements. Worked on the AI Hub on top of it, a full-stack engineering dashboard that unifies GitHub, Jira, Claude and Codex telemetry into one view. Cut developer workflow times by up to 10% by instrumenting and optimising the organisation's agent skills, with automated ticket-to-skill detection surfacing the right skill against incoming work. Indexed the codebase with my own Nexus-MCP server so coding agents could work against it. Built a company-level engineering cycle-time model on the GitHub GraphQL API: since the team ledger only reflected current membership, not history, each PR is attributed to a team by backtracking historical contribution share, with a manager-facing deny-list that reassigns mis-attributed contributors automatically — a correction loop instead of a manual audit. Also turned the repeat manual investigation behind every new feature spec — tracing problem depth, mapping affected data points, checking downstream impact, quantifying business case — into four reusable skills, collapsing a multi-round process into a single invocation without losing rigor.

Skills: Developer Productivity, AI Adoption Telemetry, Data Platforms, Snowflake, Governed Metrics, Okta SCIM/OIDC, Terraform, CI/CD, Argo CD, Full-Stack Dashboards

Founding AI Engineer — Klyft Technologies

Sep 2025 — Nov 2025

• Context: Health & Wellbeing Coaching Platform
• Problem: Multi-agent coaching responses were too slow and too expensive to serve: the heaviest messages carried ~100k tokens of raw wearable data and context.
• Architecture: Eight agents (orchestrator plus coaching, workout, nutrition, wellbeing, insights and logging) on Google ADK and Gemini via Vertex AI; Pub/Sub for async processing of wearable data; Vertex AI memory for personalisation; scheduled Gemini Flash-Lite jobs for wearable summaries; OpenTelemetry tracing per agent step; Terraform on GCP.
• Outcome: Cut tokens on the heaviest messages 10x (~100k → ~10k) by pre-summarising wearable data and scoping each agent's data access to its own tools. Evaluated Gemini 2.5 Flash against Pro on golden datasets to near-parity, so Pro never ran in production. Made the core workout-calibration agent 3x faster (60s → 20s) with async Pub/Sub processing, using OpenTelemetry to separate data, LLM and agent-step latency. Moved wearable summarisation to scheduled Flash-Lite jobs, trading 3–4 hours of freshness for lower spend. Built a rolling 16-week plan that adapted to activities detected from watch data. Vertex AI observability showed that the plans suited athletes while most users were everyday consumers, which changed the product direction.

Skills: Agentic AI, Context Engineering, Model Routing, Multi-Agent Systems, LLM Cost Optimisation, Pub/Sub, Vertex AI, GCP

Consultant (Pro Bono) — We Are Human Agency AB (Move By Vision)

Dec 2025 — Jun 2026

• Context: Healthtech Platform
• Problem: Inherited a failing Flutter + GCP platform in critical-failure alpha phase with severe latency and crashing issues, compounded by strict compliance requirements in healthcare.
• Architecture: Flutter, Vertex AI integrations with a guard-railing and validation layer and agent output contracts, OpenTelemetry, golden datasets, GCP.
• Outcome: Removed 100% of AI-induced crash failures over the release in alpha-stage testing, cut generation latency by 55% (15s to 7s) with OpenTelemetry and golden datasets, and ran a GDPR and EU AI Act audit that produced the 19-item remediation roadmap that made the system releasable.

Skills: Rescue Engineering, GDPR / EU AI Act Audit, AI Guardrails, Vertex AI, Performance Tuning

Chief Data Officer (Founding Team) — Scan and Sew Inc.

Oct 2024 — Aug 2025

• Context: 3D Product Designers & Manufacturers
• Problem: Designers lacked a unified way to intuitively search past design libraries and required a spatial CAD 2D-to-3D workflow connected to supply chain operations.
• Architecture: OpenAI LLM/VLM APIs, a Meta Llama vision model via NVIDIA, VLMs on a cloud GPU via Ollama for live inference, RAG, Gaussian Splatting (PyTorch3D evaluation), ReactJS, AWS Lambda, GraphQL, DynamoDB.
• Outcome: Shipped a Designer AI Assistant (RAG and vision-language models over the design team's internal libraries, co-built with the designers and adopted into their daily workflow) and a real-time manufacturing tracking platform. Evaluated custom 3DGS vs APIs and made the strategic call to integrate an API, saving months of dev time.

Skills: Generative AI, Gaussian Splatting, React, AWS, VLM, RAG

Founder & CTO — AIMAGE Technologies

Jan 2020 — Aug 2023

• Context: Enterprise Retailers
• Problem: Retailers losing customers because online platforms lacked an intuitive way to visually try-on items and search through massive catalogs.
• Architecture: Custom vectoriser model and custom graph-based vector database for visual search (feature vectors as nodes, ontology relationships as edges) combining similarity search with graph traversal for relationship-aware queries across catalogs of thousands of products; virtual try-on engine (OpenCV, PyTorch, Unity3D); production deployment on AWS (Lambda, ECS, Neptune, DynamoDB, S3, Kinesis) with GraphQL APIs.
• Outcome: Delivered search and recommendations to production on e-commerce platforms, cutting the p95 latency of visual search from 15s to 3–4s with knowledge graphs, and piloted the virtual try-on engine on a retail client's storefront. Founded the company, owned the product end to end for 3.5 years, and grew the team to 10 across engineering, product and design.

Skills: Vector Search, Graph DB, Computer Vision, AWS, PyTorch, GraphQL, E-commerce

Founder & Consultant (Part-time) — Mage Ventures Pvt. Ltd.

Oct 2019 — Mar 2021

• Context: PhonePe (Walmart-owned), Grocery Retail Client
• Problem: Needed a secure cross-platform payment gateway and an AI-powered automated checkout solution for retail environments.
• Architecture: Node.js, React, AWS EC2, TensorFlow, FastAPI, Computer Vision.
• Outcome: Implemented a secure cross-platform payment gateway for Walmart-owned PhonePe across multiple client apps, and built an AI-powered automated grocery checkout engine using computer vision (image segmentation) for a product company.

Skills: Payments, Computer Vision, TensorFlow, AWS, Node.js

AI Consultant (Contract, Founding Team) — Cellstrat Inc.

Oct 2018 — Oct 2020

• Context: TVS Motors, Target, Airbus, Volvo
• Problem: Bridging theoretical AI capabilities and what enterprise organizations can actually absorb and use in a real context.
• Architecture: PyTorch, TensorFlow, Keras, Python, Docker, AWS.
• Outcome: Consulted on AI/ML initiatives for enterprise clients, designing and implementing models in PyTorch, TensorFlow, Keras, and Python, containerised with Docker and deployed on AWS for their digital transformation journey. Delivered a workshop at ODSC (Open Data Science Conference) on implementing AI and deep learning solutions in enterprise environments, training 100+ professionals.

Skills: ML Consulting, PyTorch, TensorFlow, AWS, Docker

Full Stack Engineer (Founding Team) — EndGate Global

Jul 2017 — Jul 2018

• Context: High-volume food delivery services
• Problem: Needed a scalable automation platform for processing and delivering food orders in bulk.
• Architecture: Java, Spring, Hibernate, MySQL, JavaScript.
• Outcome: Developed full-stack food delivery workflows that real businesses depend on, establishing fundamental production software engineering skills.

Skills: Full Stack, Java, JavaScript, MySQL

AI Researcher Intern — ISRO

Nov 2016 — Apr 2017

• Context: Chandrayaan Moon Rover Mission
• Problem: Making a rover navigate a lunar environment using a single camera. Solving for geometric uncertainty and edge cases where failure has massive real-world consequences.
• Architecture: Computer Vision algorithms, Mono Vision Depth Detection.
• Outcome: Advanced the perception capabilities of the rover, learning the discipline of high-stakes, fault-intolerant research.

Skills: Computer Vision, Depth Detection, Research, Space AI

Nexus-MCP: Hybrid Code Intelligence Server (Mar 2026)

Built to unblock a client engagement: a large, undocumented Flutter codebase that AI agents could not navigate reliably. Combines vector search, BM25 and a structural code graph (containment, imports and call edges), so an agent gets the relevant code instead of whole files. Measured: 95% fewer tokens than Grep and Read to reach the right file (median, 10 repos in 10 languages), and lower cost per task on 8 of 11 repos in live Claude Code runs. Published on PyPI (nexus-mcp-ci, v2.4.6) and the official MCP Registry, and listed on the Glama MCP marketplace. Anyone can check the fit on their own code with a free, offline eval (uvx nexus-mcp-ci eval) that calls no LLM and sends nothing. 8 tools in one local server, tree-sitter parsing across 25+ languages, about 90 MB idle and 460 MB with the embedding model loaded, no cloud dependency and no API keys.

Problem:

AI coding agents spend most of their token budget reading irrelevant code — grepping for a function, reading entire files, repeating for every dependency. Existing code intelligence tools are fragmented across separate servers, each consuming 500 MB+ RAM.

Approach:

Built a single MCP server consolidating two predecessor projects. Dual parsing (tree-sitter for symbol extraction, ast-grep for structural graph) feeds vector and BM25 search fused with Reciprocal Rank Fusion (vector 0.5 + BM25 0.3), with a code-graph boost for hub symbols. Added an ONNX Runtime model path (~50 MB vs ~500 MB on PyTorch) alongside the default bge-small-en model, used LanceDB with mmap for disk-backed vectors, and added token budgeting, semantic memory, call-edge resolution, and production hardening (graceful shutdown, corrupt index recovery, rate limiting, audit logging). v2.1.0 cut the tool list from 10 to 8 and removed FlashRank re-ranking, after benchmarks showed that fewer, richer tools and smaller results cost less. v2.2.0 added nexus-mcp-ci eval: a free, offline check that compares Nexus-MCP with Grep and Read on questions made from the user's own code, plus an opt-in paid tier that runs Claude Code or Codex with a spend cap. Every published benchmark number now comes from one results file, and CI fails when a generated block is out of date. v2.3.0 added nexus-mcp-ci setup, one command that installs the server in Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Gemini CLI, Codex and Cline. v2.4 closed the parser gaps for C, C++, C#, PHP and Rust and published results for 12 repos in 10 languages, including the two where Nexus-MCP does not win yet.

Result:

Measured: 95% fewer tokens than Grep and Read to reach the right file (median, 10 repos in 10 languages), and lower cost per task on 8 of 11 repos in live Claude Code runs. 8 tools, about 90 MB idle and 460 MB with the embedding model loaded — indexing, hybrid search, symbol lookup with callers and callees, a call graph with transitive impact analysis, persistent memory and architecture mapping across 25+ languages. 1,676 tests, 24 Architecture Decision Records, published on PyPI (pip install nexus-mcp-ci) and the official MCP Registry, listed on the Glama MCP marketplace, CI/CD with trusted publishing. Zero API keys, fully local.

Tags: MCP, ONNX Runtime, LanceDB, rustworkx, tree-sitter, Pythonhttps://jaggernaut007.github.io/nexus-mcp/https://github.com/jaggernaut007/Nexus-MCP

Protash: Autonomous Enterprise Prototyping Platform (Sep 2026)

Describe a business intent; get a working, deployed prototype back in under 5 minutes. A hosted multi-agent tool that turns a described business goal into a running prototype autonomously — a 6-stage pipeline extracts domain context, spec and UX plan, generates a self-contained React component, then QAs and reviews it in parallel, self-healing through up to five correction rounds before anything reaches the screen.

Problem:

Most prototyping tools produce generic wireframes — stakeholders see "Lorem ipsum" and "User A" and immediately check out, so a described business idea never gets a real gut-check before it's built.

Approach:

Next.js/TypeScript multi-agent orchestrator and message bus: businessContext and spec agents extract domain entities, KPIs and BDD success criteria, a UX architect picks layout, charts and realistic domain-specific mock data, then a generator produces a sandboxed React component while QA and Reviewer agents run in parallel and request targeted fixes on failure. Built on DeepSeek V4.1 Flash, with a token budget and reasoning effort set for each agent role, to keep cost per run low. Hardened for a public demo: generated code compiles and runs in an opaque-origin sandbox iframe with its own CSP (no network, imports limited to React and Recharts), and a global LLM spend cap (runs a day and runs in flight) sits on top of per-IP limits, because per-IP limits alone do not stop an attacker with many addresses. Deployed on GCP Cloud Run via Cloud Build with runtime secrets from Doppler, with Vitest, Playwright and an evaluation suite.

Result:

A working, deployed prototype back from a plain-English business intent in under 5 minutes — wired with plausible domain data rather than placeholders. The evaluation suite scored 8.7/10 on average over 8 cases, and one run costs up to about $0.30 at peak prices.

Tags: Multi-agent, Next.js, GCP Cloud Run, DeepSeek V4.1 Flash, Sandboxed iframe, Live demohttps://protash.shreyasjagannath.comhttps://github.com/jaggernaut007/Protash

CR8: Curriculum-to-Content Agent Pipeline (Mar 2026)

Built a 3-agent LangGraph pipeline (Ingest → Research → Generate) that turns raw university curriculum into a complete learning package: structured study guides, gap-analysis decks, video scripts, AI-narrated video, and a Bloom's-taxonomy MCQ quiz engine. A two-layer evaluation framework gates every output, and severity-based model routing keeps generation cost near zero without dropping quality where it matters.

Problem:

Turning raw curriculum into structured learning content is manual, slow, and inconsistent — and without evaluation, generated educational material can't be trusted for real use.

Approach:

3-agent LangGraph pipeline (Ingest → Research → Generate) producing study guides, gap-analysis decks, video scripts, AI-narrated video via Kokoro TTS, and Bloom's-taxonomy MCQ quizzes. A two-layer evaluation framework: free structural checks on every output, plus a DeepSeek-V3 LLM judge at roughly $0.02 per run, with severity-based routing across GPT-5-nano/mini/5.1.

Result:

End-to-end curriculum-to-content system in production on Cloud Run — guides, decks, narrated video and assessment generated from a syllabus, with every output scored before it ships. 1,299 tests across pytest, Vitest and Playwright E2E, with zero real API calls in the suite.

Tags: LangGraph, FastAPI, React, GCP Cloud Run, Kokoro TTS, DeepSeek-V3, Pytest, Vitest, Playwright, Python

Agent Harness: Secure Live-Data Dashboard Framework (Sep 2026)

A Python agent harness that connects to live data sources — databases, APIs, GCP infra — and builds validated dashboards, with every SQL path routed through one read-only guard by construction and no response model ever carrying a credential back to the LLM. In active development (MVP, Stage 3 of 5): the FastAPI gateway, SSE streaming and credential-hardening layer are built and tested (274 passing tests); the front-end and Cloud Run deploy are still ahead.

Problem:

Giving an LLM agent live database access safely means the credentials and the query surface both have to be structurally impossible to leak or escape — not just documented as read-only, but enforced that way in code, since a single missed path is the whole failure mode.

Approach:

Every SQL execution path — panel data queries, connection introspection, ad-hoc exploration — routes through one sqlglot-based read-only guard rather than each call site trusting its own discipline; the connections API's response model has no field for a secret to occupy, so "never returns secrets" can't regress silently. The redaction layer went through repeated adversarial review: a Stage 1 security review found and closed a real guard bypass, and a later verification round found a ReDoS in the credential-matching regex (2.4s down to 8ms on a 64KB input) and a quoted-dict-repr secret leak the first pass had missed — each fix re-verified against the live code path, not just the reported case.

Result:

Stage 3 of 5 (MVP plan): headless pipeline and credential hardening complete, FastAPI gateway live with SSE streaming and 274 passing tests. First live-model eval baseline: 3 of 8 scenarios passed end-to-end on DeepSeek — the honest current number. Front-end and Cloud Run deployment are the open next stages.

Tags: Agentic Systems, Security, LLM Guardrails, FastAPI, SQL Guardrails

JobScout: Employer-Aware Job Discovery Pipeline (Mar 2026)

A daily pipeline that pulls roles from 13 ATS platforms and several job boards, checks each employer and salary against fixed rules, and scores what's left in two tiers: a free keyword pass first, then one LLM call only for jobs that survive it.

Problem:

Job boards don't say which employers meet a search's hiring rules. Checking each company by hand didn't scale.

Approach:

Async connectors for 13 ATS platforms across 340+ companies, plus 8 vibe-search portals, feed a three-node LangGraph evaluator: deduplicate and embed; keyword scoring, an embedding pre-filter and employer and salary gates; then a single LLM scoring call for whatever survives. Employers are matched against public registers.

Result:

~30,000 jobs fetched per day (median across the GB batch, last 30 days). The free keyword tier eliminates roughly 80% of irrelevant jobs before any reach the LLM tier, keeping real measured LLM cost under $0.01/day. 1,035 tests.

Tags: LangGraph, Dual-Tier Scoring, Employer Matching, Data Pipeline

Health Intelligence Engine: Agentic Wellness Platform (Jan 2026)

Clinical AI platform that turns supplement queries into evidence-grounded, safety-checked recommendations. A 9-node LangGraph pipeline grounds product data against NIH DSLD and PubMed in a Neo4j knowledge graph, with a Pharmacovigilance Critic checking every recommendation against the user's allergies and medications.

Problem:

Supplement and wellness recommendations lack grounding in clinical evidence and fail to account for individual contraindications, creating real safety risks for users.

Approach:

9-node LangGraph pipeline grounding product data against NIH DSLD and PubMed in a Neo4j knowledge graph. A Pharmacovigilance Critic node checks every recommendation against the user's declared allergies and medications. DeepEval quality gates enforce output standards; published healf CLI exposes the platform.

Result:

Evidence-grounded wellness guidance with built-in safety guardrails, contraindication checking, and DeepEval-validated output quality. Published as a CLI tool.

Tags: LangGraph, Neo4j, Knowledge Graphs, RAG, Safety Guardrails, DeepEvalhttps://github.com/jaggernaut007/healthAgent

Context-Aware Knowledge Graph Agent (Dec 2025)

Built a Python-based NLP agent that converts raw consumer data into a Neo4j knowledge graph and structured vector store, feeding OpenAI, Gemini and Veo 3.1 video generation components with user-specific context for hyper-personalised video content.

Problem:

Consumer data sits in unstructured formats (search histories, browsing data) with no way to extract personalised context for content generation at scale.

Approach:

Built an NLP pipeline: data dedup, temporal clustering, cluster-level NER with GPT-5-nano, Neo4j graph construction, Gemini script generation, and Veo 3.1 video rendering.

Result:

11 semantic categories extracted at sub-$1 API cost via cluster-level batching. 40+ reusable Cypher query patterns. Hyper-personalised video content generated from raw search history.

Tags: Knowledge Graphs, Neo4j, NLP, Video Generationhttps://github.com/jaggernaut007/fabric-context-portability

Autonomous Agentic B2B Data CRM (Nov 2025)

Implemented an end-to-end agentic data pipeline to automatically crawl the web, qualify companies, enrich contacts and persist leads into an Enterprise GraphQL CRM.

Problem:

Sales and Go-To-Market teams spent much of their time on manual lead enrichment, qualification, and data-entry overhead.

Approach:

Deployed an asynchronous multi-agent orchestration pipeline on GCP to autonomously crawl, heuristically score, and persist enriched B2B leads.

Result:

Automated the top-of-funnel data generation process end-to-end, seamlessly mapping unstructured web data into an enterprise relational backend.

Tags: Agentic AI, Data Pipelines, CRM Architecture, GCPhttps://github.com/jaggernaut007/RevGeniAgent