Vinayak

AI Engineer

I build agents that run real tools and cite their sources

About

I’m an AI Engineer at AMnova Technologies architecting full-stack multi-agent systems with FastAPI LangGraph and Next.js

My focus is practical reliability building agents with sandboxed code execution source-grounded citations and deterministic guardrails that prevent hallucinations

  • Agent Runtime & RAG2026 · Solo build

    Loom.ai

    One AI workspace to chat code in a live sandbox study and delegate

    • Sandboxed execution The Code agent gets a real Linux box (shell filesystem web search dev servers) and streams every tool call over a typed FastAPI WebSocket contract into a live trace and preview
    • Grounded retrieval Learn turns PDFs web pages and YouTube transcripts into answers with [n] citations and graded courses and abstains when the sources don't cover the question
    • Resilient routing Each iteration is classified and routed across eight models

    8.9 → 5.0 sMedian time to first token with prompt caching

    • LangGraph
    • FastAPI
    • Next.js
    • E2B Sandbox
    • pgvector
  • Semantic RAG & Guardrails2026 · Solo build

    LazyHire

    Nine Kerala job boards one ranked list no duplicates

    • Ingest and deduplicate Aggregates 9 job sources validates apply links and deduplicates postings on canonical URL plus company title and location
    • Transparent ranking Ranks jobs with local MiniLM embeddings and SQLite FTS5 across freshness source quality location role fit and skills so every match score can be inspected
    • Guardrails and security Rejects tailored CV output that fabricates numbers or requirements

    9Job sources merged and deduplicated

    • Next.js 16
    • React 19
    • TypeScript
    • SQLite + FTS5
    • Drizzle ORM
  • Explainable ML + Voice2026 · Solo build

    ARIA

    Predicts which customers will leave then explains why in plain words and voice

    • Imbalanced classification XGBoost trained on 10,000 customer records with SMOTE for class imbalance and one scaler shared by training and inference
    • Risk tiers and drivers FastAPI serves real-time churn probabilities grouped into Low Medium and High risk alongside global feature-importance rankings
    • Explanation and voice Llama 3.3 70B writes plain-language explanations and next-step retention strategies; ElevenLabs speaks them

    10kCustomer records trained on

    • XGBoost
    • SMOTE
    • scikit-learn
    • FastAPI
    • Llama 3.3 70B (Groq)
  • Clinical ML · Live + DOI2026 · Solo build

    PredictLab

    Screening results that explain themselves

    • Three disease models An SVM for diabetes a Random Forest for stroke and Logistic Regression for heart disease each in its own scikit-learn pipeline
    • One FastAPI service A single FastAPI backend serves the web interface the prediction endpoints and the AI assistant with no frontend build step containerized with Docker
    • Contextual explanations Patient inputs and model outputs go to Llama 3.1 8B on Groq which explains the result in plain language and answers follow-up questions

    3Clinical screening models

    • scikit-learn
    • FastAPI
    • Llama 3.1 (Groq)
    • Docker
    • Hugging Face Spaces
  • Multi-Agent Analytics2026 · Archive spotlight

    InForge-AI

    Drop in a CSV get a full analysis: eight agents zero manual steps

    • Eight-agent pipeline Ingest clean EDA visualize ML benchmark insights code gen and chat run in turn on one uploaded CSV streamed live over WebSockets
    • Local ML fallback pandas scikit-learn and XGBoost compute every numerical result locally so provider outages never break the core analysis
    • Model benchmarks Four ML models are benchmarked on every run and the core analysis needs no LLM calls

    8Autonomous pipeline agents

    • FastAPI
    • WebSockets
    • React
    • pandas
    • scikit-learn
    • XGBoost
    • Gemini
    • Groq

Loom.ai

One AI workspace to chat code in a live sandbox study and delegate

  • LangGraph
  • FastAPI
  • Next.js
  • E2B Sandbox
  • pgvector
  • Groq
  • OpenRouter
  • WebSockets
github.com/vinayak533/loom.ai
Loom.ai: silent screen recording of the product in use.

8.9 → 5.0 s

Median time to first token with prompt caching

Median time to first token per turn before and after transcript caching on a ~80k-token loop (4 tool rounds) Per-turn range: 4.6–22.0 s before 3.4–5.1 s after

8

Models routed with automatic provider fallback

Models in the routing table across Groq OpenRouter and OpenCode as listed in the README A failed call retries on at most two alternates

10

Specialist agents with human approval

Specialist agents on one parameterised graph each pausing for human approval as listed in the README

PROBLEM

Chat windows can't execute code or check answers against private documents Coding research and study each need their own tools and a real environment to run in

MECHANISM

LangGraph agent in an E2B sandbox; turns routed across 8 models retried on up to 2 alternate providers

SOURCED CLAIMS · CLICK ONE TO HEAR IT

  1. Chatbots talk about code Loom runs it inside a real Linux sandbox

  2. Every turn is routed across 8 models If a provider fails the turn falls back to the next one

  3. Caching the transcript cut the median time to first token measured turn by turn

  4. And the limits are written down too

route_turn() · try it: take a provider down

turn
classified

Each provider toggles up/down Primary first then up to two alternates

Provider names from the project; the replay is illustrative

time_to_first_token() · median ~80k-token test loop

No cache8.9 s
Cached transcript5.0 s

Measured values from the performance method doc; playback is 10× faster than real time

CLICK A STAGE:

Turn Classifier & Router

Routes across 8 models (Groq OpenRouter OpenCode) with 2-hop provider fallback

LangGraph Checkpointer

Persists graph state after every node visit; caches ~80k-token transcript

E2B Sandbox & pgvector

Concurrent read-only tool batches; sequential writes; lexical hashed RAG

INPUTS

User Prompt / Task · Repo Filesystem · PDF · Web · YouTube Sources

OUTPUTS

Typed WebSocket Trace · Live Dev Server Preview · Cited [n] Notebook Answers

Sandboxed execution

The Code agent gets a real Linux box (shell filesystem web search dev servers) and streams every tool call over a typed FastAPI WebSocket contract into a live trace and preview Read-only tool batches run concurrently; writes run in order

Grounded retrieval

Learn turns PDFs web pages and YouTube transcripts into answers with [n] citations and graded courses and abstains when the sources don't cover the question Retrieval uses lexical hashed vectors in pgvector

Resilient routing

Each iteration is classified and routed across eight models On a rate limit quota or 5xx it retries on up to two alternate providers and LangGraph checkpoints let sessions survive cold starts

STACK (8 TOOLS)

Orchestration
  • LangGraph
  • Multi-Agent Graph
  • Prompt Caching
Backend & Data
  • FastAPI
  • WebSockets
  • pgvector
  • SQLite Checkpointer
Model / API Layer
  • Groq
  • OpenRouter
  • OpenCode (8 Models)
Runtime & UI
  • E2B Sandbox
  • Next.js

DOCUMENTED LIMITS (3 OF 26)

  • Rate limiting is in-process
  • The checkpointer defaults to SQLite on local disk
  • One concurrent run per session

LazyHire

Nine Kerala job boards one ranked list no duplicates

Here’s a simulated run of the CV guard Pick the edit you think it rejects

tailor_cv() · pick an AI-suggested edit

source CV (fictional)Built a FastAPI service that parses supplier invoices into PostgreSQL

One of these edits invents something The guard will catch it

Toy guard: it checks numbers only LazyHire's real checks cover numbers and requirements

github.com/vinayak533/lazyhire
LazyHire: silent screen recording of the product in use.
  1. LazyHire pulls 9 job sources around Kerala's tech parks into one ranked list minus the duplicates

  2. Every match score opens up: freshness source location role fit and skills

  3. It tailors your CV and rejects any edit it can't trace back to the original

  4. The code is public: read it on GitHub

Job sources merged and deduplicated
9
Job sources the ingest step aggregates deduplicated on canonical URL plus company title and location
Application stages tracked
4
Stages in the app's application tracker
Private guarded CV review
PDF · DOCX
CV formats the private review accepts

ARIA

Predicts which customers will leave then explains why in plain words and voice

A toy dial not the trained model: drag it to see how the risk tier changes

score_churn() · illustrative toy not the trained model

Low risk

p(churn) ≈ 12%

Low risk Activity is recent so the usual check-ins are enough

github.com/vinayak533/bank-churn-intelligence-platform
ARIA: silent screen recording of the product in use.
  1. ARIA predicts which bank customers might leave: XGBoost on 10,000 records balanced with SMOTE

  2. It sorts them into Low Medium and High risk and surfaces the top five drivers

  3. Then Llama 3.3 explains why in plain words and ElevenLabs reads it aloud

Customer records trained on
10k
Rows in the bank-customer training dataset per the README
Actionable risk tiers
3
Churn-probability bands from the README: Low ≤35% Medium 35–65% High >65%
Top predictive features surfaced
5
Global feature importances from the trained model shown in the UI They rank the model's drivers overall not per customer

PredictLab

Screening results that explain themselves

github.com/vinayak533/PredictLab
PredictLab: silent screen recording of the product in use.
  1. PredictLab screens for diabetes stroke and heart-disease risk from 30 health inputs

  2. Three models an SVM a Random Forest and a Logistic Regression behind one FastAPI service

  3. Llama 3.1 explains every result in plain language Vinayak published it as a preprint

Clinical screening models
3
An SVM (diabetes) a Random Forest (stroke) and a Logistic Regression (heart disease) each a scikit-learn pipeline behind one FastAPI service
Health inputs analysed
30
Input fields across the three screening forms: 8 + 10 + 12

Skills & technologies

What I build with

Each tool links to the project or role that used it.

  1. Python for the AI and ML work, TypeScript for the Next.js front ends, and SQL for the data underneath.

    See it in use in LazyHire
  2. Agents that call real tools, routed across models with fallback, retrieval that cites its sources, and guardrails that reject made-up output.

    See it in use in Loom
  3. scikit-learn and XGBoost for tabular models, feature engineering on skewed data, MLflow to track experiments, and pgvector for retrieval.

    See it in use in Amdox
  4. FastAPI services over REST and WebSockets, Next.js on the front, and agents that run code inside E2B Linux sandboxes.

    See it in use in Loom
  5. PostgreSQL and Supabase for data, SQLite where it runs locally, and Docker and CI/CD to ship to AWS.

    See it in use in AMnova

Professional experience

Where I’ve worked

  1. Jun 2026 – Present

    AMnova Technologies

    AI/ML Engineer · Kochi, India
    LLM store-audit pipeline
    ROLE & RESPONSIBILITIES

    AI/ML engineer on the product team. I work on the LLM pipeline that checks new merchant stores and the backend behind the merchant dashboard.

    KEY CONTRIBUTIONS & IMPACT · SELECT ONE FOR DETAILS
    • Built the LLM pipeline that checks new merchant stores at AMnova: It speeds up the store audits that were done by hand during merchant onboarding.

      • Python
      • LangChain
      • FastAPI
    • Wrote the FastAPI + Supabase backend behind the merchant dashboard: Its queries run async.

      • FastAPI
      • Supabase
    • Packaged the inference services in Docker: GitHub Actions deploys them to EC2 on every push.

      • Docker
      • AWS EC2
      • GitHub Actions
    STACK //
    • Python
    • LangChain
    • FastAPI
    • Supabase
    • Docker
    • AWS EC2
    • GitHub Actions
  2. Apr – May 2026

    Amdox Technologies

    Data Science Intern · Bengaluru, India
    Forecasting and churn models
    ROLE & RESPONSIBILITIES

    Built retail demand-forecasting and customer-churn models and served them as FastAPI endpoints.

    KEY CONTRIBUTIONS & IMPACT · SELECT ONE FOR DETAILS
    • Built demand-forecasting and churn models: XGBoost and scikit-learn on transaction histories.

      • Python
      • XGBoost
      • scikit-learn
    • Served the models behind FastAPI endpoints: Other apps call them over REST.

      • FastAPI
    • Tracked experiments in MLflow and built Streamlit dashboards: So the business team could see the results.

      • MLflow
      • Streamlit
    STACK //
    • Python
    • XGBoost
    • scikit-learn
    • FastAPI
    • MLflow
    • Streamlit
  3. Aug – Sep 2025

    Cognifyz Technologies

    Data Science Intern · Remote
    Credit-approval classifiers
    ROLE & RESPONSIBILITIES

    Built credit-approval classifiers on a heavily imbalanced financial dataset.

    KEY CONTRIBUTIONS & IMPACT · SELECT ONE FOR DETAILS
    • Trained and tuned credit-approval classifiers: Checked on F1, precision, recall and ROC-AUC, not accuracy alone, because the classes are skewed.

      • Python
      • scikit-learn
    • Feature engineering, outlier cleaning and class-imbalance handling: On skewed applicant data.

      • pandas
      • Feature engineering
    STACK //
    • Python
    • scikit-learn
    • pandas
    • Feature engineering
    • ROC-AUC

Certifications & achievements

The Record

NEO // run for vinayak k v
—

  1. Nothing printed yet. Scroll the page and I'll log each step.

Each line links back to its step.

Tearing copies a plain-text summary, with Vinayak's email, to your clipboard.