Tanmay Khanna, Lucknow, India

AI Systems Engineer

Building intelligent systems across data, AI, agents, automation, and open source.

I work at the intersection of the layers that have to hold together before an AI system is useful. Pick a stage below to find it on the map.

data Raw audio, images, video, and medical files, filtered, checked, and deduplicated until a dataset can be trusted.
01about

I build systems that connect data, software, AI, automation, and intelligent agents.

I like to understand a system from first principles before I add anything to it. That habit shows up everywhere in my work: reading a codebase until its structure makes sense, breaking a vague problem into constraints, and turning a complicated idea into software that runs.

So far my work spans backend systems, AI applications, RAG, agents, MCP, multimodal data, automation, data processing, open source, and evaluation. It moves between low-level engineering, like deduplicating audio in bulk, and higher-level AI design, like deciding how an agent should behave when a fixed workflow breaks.

I'm early in my career. My current role at InfoBay.AI began in 2026, so what I bring is depth in a few areas, breadth across the stack, and a steady rate of learning. The rest of this page shows the work instead of claiming it.

whoami: Tanmay Khanna, AI Systems Engineer. Focus: multimodal data, agent architectures, evaluation. Status: early career, learning fast, building in public.

Data infrastructure
Filtering, structuring, quality checks, deduplication, and archival for multimodal datasets.
Backend and AI applications
APIs, RAG pipelines, and tool-using services built with FastAPI, Node.js, and LangGraph.
Agents and automation
Deterministic browser automation with agentic fallback, MCP integrations, and human approval where it matters.
Evaluation and research
Measuring what a model actually does, and analysing where and why it fails.
Open source
Reading, refactoring, and contributing to real codebases.
02experience

Junior AI Engineer

InfoBay.AI

Lucknow, India. to present.

I work across the data lifecycle required to make multimodal AI systems possible.

The job is not scraping. It's everything between raw files and a dataset a model can be trained or evaluated on: deciding what belongs, structuring it, checking it, removing what shouldn't be there, and moving it safely at scale. I've worked with audio, images, video, and multimodal datasets.

Data processing

  • Raw data filtering
  • Structuring raw data into consistent formats
  • Quality checks
  • Metadata processing
  • PII removal
  • Deduplication
  • Sampling
  • Automating the repeatable parts

Each step exists to make the next one trustworthy.

03data

The infrastructure behind an AI dataset

A model is only as good as what it was trained and tested on. My work at InfoBay.AI exposed me to the practical machinery around that: where data comes from, how it moves, what gets rejected, and how the survivors are stored. That is the part of AI that rarely shows up in demos.

Illustration Particles are records. Amber ones are rejected along the way. The stream narrows because most raw data doesn't survive. No real volumes are shown.

Select a stage to see what happens there.

04systems

AI systems and agents

Two systems I'm designing and building. Each diagram is interactive: hover a technology to see where it sits, or run the walkthrough.

AI Knowledge Platform

Architecture

A retrieval and reasoning service built around a planner, hybrid retrieval, reranking, and a reasoning step that produces the final response. Conversational memory and evaluation are part of the design, and I'm using it as a place to experiment with LoRA and QLoRA.

  1. retrieval

Select a stage for details.

Illustrative trace. No model is running on this page.

  1. Run a sample query to see how a request moves through the stages.

Local Agentic Job Engine

In progress

A privacy-oriented, local multi-agent system that automates parts of the engineering job-application workflow. It's a personal systems project and an experiment in local, privacy-conscious, resilient browser automation. It is not a finished production system.

Use deterministic automation whenever the workflow is known, and use agents only when deterministic automation cannot reliably handle the situation.
  1. incoming jobA posting enters the system.
  2. ingestionNormalised into a structured record.
  3. URL / ATS detectionIdentify which application system this is.
  4. cached deterministic workflow A stored, scripted path for systems already seen. hit: replay the script miss: hand over to an agent
  5. agentic fallback, used only on a miss

    1. LLM agentTakes over the unfamiliar form.
    2. DOM / AXTreeReads the page structure and accessibility tree.
    3. reasoning agentDecides the next action from what it sees.
  6. browser automationDrives the browser to fill the form.
  7. validationChecks every field against a schema before anything is sent.
  8. submit / human approvalA person decides whether it goes out.
  9. trackerRecords what happened.

who is acting

  • deterministic runner
  • LLM agent
  • reasoning agent
  • human

Walkthrough of the intended flow. Nothing is executing.

  1. Pick a scenario and run the walkthrough.
input dataread-only

docker container

  • non-root user
  • restricted mounts
  • local inference
output directorywrite-only

Security architecture

A non-root container, restricted mounts, read-only input data, a write-only output directory, and local inference. These choices reduce exposure. They don't make the system perfectly secure, and nothing here is a claim about getting past anti-bot systems.

Hardware target

An RTX 5070 with 12 GB of VRAM, which is why the models are small, quantisable, and served locally with vLLM.

What I plan to measure

Planned benchmark metrics for the Local Agentic Job Engine. None have been measured yet.
MetricWhat it tells meStatus
Application completion rateHow often a started application reaches a valid submission.Implementation in progress
Human intervention rateHow often a person has to step in.Implementation in progress
Workflow recovery rateHow often a failed step recovers without help.Implementation in progress
Model calls per applicationThe cost of using agents at all.Implementation in progress
LatencyTime from posting to ready-for-approval.Implementation in progress
VRAM usagePeak memory on the 12 GB target.Implementation in progress
Deterministic vs agentic ratioHow much work the cached workflows absorb.Implementation in progress

No numbers appear here because none have been measured yet.

05research

Research and evaluation

SAGA — Source Attribution of Generative AI Videos

Research / Exploration Phase 1 implemented: real vs AI Source attribution: open

A research and engineering project about identifying AI-generated video and investigating where it came from. It combines video analysis, spatial and temporal transformations, and questions of provenance and dataset quality.

Phase 1 has been implemented for real vs AI detection. Source attribution remains an active research challenge, particularly because reliable attribution depends heavily on appropriately labeled and detailed training and evaluation data.

  1. analysis

Select a stage for details.

Challenges I ran into

Real video with camera artifacts

Sensor noise, compression, and stabilisation leave traces on genuine footage. A detector has to separate "unusual" from "generated", and those are not the same thing.

Poor CGI and VFX

Low-quality CGI can share visual tells with generated video. The question is about origin, not realism, which makes it harder than it sounds.

AI-assisted CGI

When artists use AI inside a traditional pipeline, it's no longer clear what "AI-generated" should mean. The label itself becomes ambiguous.

AI content combined with traditional graphics

Generated footage composited with conventional graphics blurs the source signal. One video can have several origins at once.

Provenance loss

Re-encoding, cropping, and re-uploading strip metadata and degrade the traces that attribution relies on.

False positives

Flagging real footage as AI has a real cost. It needs to be measured and analysed on its own, not averaged away inside one headline number.

Dataset labeling

Attribution needs labels that say which generator, which version, and what pipeline. Detailed labels like that are scarce and hard to verify.

No accuracy figure appears on this page. I'd rather show the failure modes than a headline metric.

AI Evaluation & Research

Evolving direction

This is a direction I'm growing into, not a credential. I'm interested in how models behave, where they break, and how to measure that honestly. Topics I'm reading about and experimenting with:

  • model evaluation
  • AI behavior
  • robustness
  • alignment fundamentals
  • interpretability
  • evaluation methodology
  • benchmarking
  • failure analysis
  • scalable oversight

model

Illustrative example of the method, not a reported result.

06open source

Open source

Unchained Caravan

Contribution

Caravan is an open-source Bitcoin multisig coordinator. I worked in its monorepo on maintainability and the interface.

Where I worked in the codebase. Select the root to expand it.

Currently exploring: Frappe and ERPNext

Exploration / Active work

This is exploration, not a finished contribution. I'm not claiming any merged work here.

  • Studying the Frappe / ERPNext (opens in a new tab) codebase
  • Investigating issue #57313
  • Investigating issue #57315
  • Understanding the existing architecture
  • Preparing potential fixes and contributions
07projects

Software projects

JerrIt

Public

An Express.js server scaffolding library, run as a CLI. It sets up a production-shaped backend in one command: project structure, dependencies, database wiring, and an optional AI module.

Node.js, TypeScript, Express, MySQL, MongoDB, GenAI module, CLI

  • Scaffolding and project structure
  • Dependency management
  • TypeScript support
  • Plugin-based backend architecture
  • Documentation

$ npx create-jerry

database
language
AI module

                

Structure as documented in the project README.

Zwip-AI

Public

A full-stack AI services platform with a separate frontend and backend, user authentication, and persistence.

  • Article generation
  • Image generation
  • Resume review
  • Background removal
  • Authentication and OAuth
clientReactClerk
APINode.jsExpress
dataPostgreSQL
AI and media servicesGeminiClipdropCloudinary

More work

  • A live-streaming platform with Lightning and Bitcoin payments, using QR codes and payment receipts.

  • Bitcoin concepts built from scratch in Python: how Bitcoin works, how Bitcoin Script works, and a take on the transaction optimization problem.

  • Argo GitOps (opens in a new tab)

    Docker, Kubernetes, Argo CD

    A DevOps project that containerises a simple Express app, deploys it to a Kubernetes cluster with Argo CD, and manages a canary release with Argo Rollouts. The README documents each step and the difficulties I hit.

08skills

Skills, grouped by what they're for

Not ranked. Depth varies: some of these I use constantly, some I've used on a project or two, and a few I'm still learning.

Languages
  • Python
  • JavaScript
  • TypeScript
  • Java
Backend
  • Node.js
  • Express
  • FastAPI
  • REST APIs
AI systems
  • LLMs
  • RAG
  • Agents
  • LangGraph
  • MCP
  • Embeddings
  • Qdrant
  • BM25
  • Reranking
  • LoRA
  • QLoRA
Data
  • PostgreSQL
  • MySQL
  • MongoDB
  • SQLite
  • Multimodal data processing
  • Deduplication
  • Metadata processing
Infrastructure
  • Docker
  • Git
  • GitHub Actions
  • Remote environments
  • NAS
  • CI/CD concepts
Automation
  • Playwright
  • Browser automation
  • Browser Use
  • Camoufox
Frontend
  • HTML
  • CSS
  • JavaScript
  • React
09github

Read the code

My GitHub profile is the primary proof of work. Anything on this page that is public links to a repository you can open. Work at InfoBay.AI is private, and for projects above without a repository link, the write-up on this page is what is public so far.

$ gh repo list TomLucasakaTGeek

Open my GitHub profile (opens in a new tab)

10log

Engineering log

Notes from building, written in public: what I built, what broke, and what I measured. These are the entries planned so far. None are written yet.

  1. [build]

    Local Agentic Job Engine

    Coming soon
  2. [research]

    Can AI-generated video be reliably separated from CGI?

    Coming soon
  3. [open source]

    Understanding Caravan's UTXO architecture

    Coming soon
  4. [systems]

    When should an agent not be used?

    Coming soon

Themes I plan to write about: AI systems, agent architectures, RAG, evaluation, open source, system design, multimodal datasets, engineering experiments, and failure analysis.

11principles

How I work

First principles
Understand the underlying system before adding abstraction.
Determinism before agents
Use deterministic systems wherever the workflow is known.
Measure before claiming
Experiments need metrics, failure analysis, and reproducibility.
Data is infrastructure
AI systems are constrained by the quality and structure of their data.
Build in public
Code, experiments, failures, and reasoning should become public proof of work when appropriate.
Open source as proof
Contributions should show that you can understand and modify real-world systems.
12contact

Let's build something interesting.

If you're working on data infrastructure, agent systems, evaluation, or open source, and this page suggests I could be useful, I'd like to hear from you.