Krisna Pranav
Software Engineer · AI/ML & Agentic Systems

I build the systemsthat make AI agentsactually work

Agentic orchestration, LLM tool-use, ML models & inference, and on-device retrieval — on a foundation of systems programming in Rust, C++, and Go.

  • Rust
  • Go
  • C/C++
  • Python
  • TypeScript
scroll into the pipeline
01 — What I build

I build the retrieval and reasoning pipelines that agents actually run on.

Three years of my work lives here: agentic systems — LLM orchestration, tool-use & function calling, multi-step reasoning, and RAG — that stay fast and cite their sources. Below is one I've shipped end-to-end, built on Anthropic and OpenAI APIs.
querytool-usevector spacererankcite?queryre-ranktop-k[1] answer
0.00+
recall@10
on ~100K-document corpora (HNSW)
<0ms
context-aware query
on-device semantic answers
<0ms
p99 vector search
on live traffic
<0ms
time-to-first-token
streaming gateway under load
also in the toolbox — models & inference
  • embeddings & vector indexing (HNSW, IVF)
  • ONNX runtime · on-device inference
  • model quantization
  • GPU/CPU pipelining
  • inference optimization
  • YOLO object detection
  • vision-LLM extraction
  • prompt & tool-use evaluation
  • model deployment & serving
  • observability & tracing for LLM workflows
02 — Systems Programming Layer

I write the performance-critical layer the AI runs on.

When an agent has to stay fast under load, I drop into Rust, C++, and Go — async task execution, memory profiling, backpressure. Close to the metal, so everything above it stays quick.
  • tokio async I/O
    non-blocking runtime for concurrent agent runs
  • lock-free concurrency
    goroutines + bounded channels, no contention
  • zero-copy serialization
    move bytes, don't copy them
memory-leak fix · tauri stress loop
0.00.0MB RSS

RSS held flat across a 3-minute stress loop after balancing an Objective-C retain/release leak upstream — the difference between a stable long-running app and a slow crash.

03 — Featured Work

Two systems I shipped, side by side.

On the left, an on-device Rust agent I built end-to-end. On the right, a production legal RAG platform. Both real, both mine — the same terminal, split.

Aether

Rust

AI Desktop Agent · on-device retrieval

aether — deploy
$ cargo build --release
Compiling aether-index v0.4.0
Compiling aether-embed v0.4.0 (onnx)
Finished release [optimized] in 41.2s
$ aether index ~/vault --watch
indexed 98,214 docs · hnsw M=16 ef=200
recall@10 0.95+ · idle 47MB · query 92ms
hnsw · on-device vector store
ef_c200
recall@100.953
query53ms
  • On-device vector store with HNSW retrieval; tuned graph params (M, ef_construction) to reach recall@10 above 0.95 on ~100K-document corpora.
  • Owned the full stack: indexer, embedding pipeline, vector store, file watcher, IPC layer, and the Tauri UI.
  • Shipped macOS and Linux binaries that idle under 50MB.

Legal RAG Platform

Python · TS

Retrieval-augmented legal information system

legal-rag — deploy
$ python -m ingest ./corpus --hybrid
parsing pdf → semantic chunks
tagging: section · clause · date · jurisdiction
upsert → vector + keyword store
vision-LLM: scanned notice → structured
✓ 12,480 chunks · reranker warm
answer returned with [3] source citations
document ingestion → citationvision-LLM
pdf
chunk
tag
store
rerank
cite
  • Ingestion end-to-end: PDF parsing → semantic chunking → metadata tagging (section, clause, date, jurisdiction) → hybrid vector + keyword store with reranking.
  • Multimodal document understanding: forwarded notices and scanned pages parsed via vision-LLM extraction, fed into the same RAG + citation pipeline.
  • Automated knowledge-base monitoring agent scrapes designated sources on a schedule, detects new orders, and re-indexes without manual intervention.
0.95+ · recall@10<100ms · query<50MB · idle mem<50ms · retrieval p99cited · answers
both passing — one engineer, many systems
03.b — More, in brief
BlockStarsvideo → reasoning

Video-based LLM parser

Live video streams feed YOLO for object detection; structured detections pass to an LLM that reasons about the scene. Written in C++, Rust, and Python — optimized for low-latency frame processing, stream to LLM output.

Trading Platformlive order book

High-throughput on-chain trading

Real-time price feeds, sub-second swap execution in Rust, wallet/whale tracking, and live charting. Trade paths optimized for minimal slippage during high network congestion. Next.js/TypeScript order books.

PayPalzero-downtime cutover

C++ → Go backend migration

Migrated critical services on a tier handling 15–20M requests/day, keeping p99 on par with the legacy system. Goroutines and bounded channels for backpressure; cutover with zero downtime via gradual traffic shifting.

Crossing Hurdlestoken streaming

Streaming inference gateway

Fans out concurrent LLM calls and streams tokens back over WebSockets/SSE, cutting time-to-first-token under 300ms. In-memory embedding cache + incremental re-indexing keep vector search under 50ms p99. Hardened in Rust with backpressure, request batching, and timeout/retry.

04 — How the work moves

Idea to production, owned end-to-end.

  1. 01

    Idea

    the problem, owned end-to-end

  2. 02

    Model / Algorithm

    the right retrieval, the right model

  3. 03

    Systems impl

    Rust · C++ · Go

  4. 04

    ML boundary

    Python · TypeScript integration

  5. 05

    Production hardening

    observability · backpressure · retries

  6. 06

    Shipped

    in production, under load

05 — Numbers that are real
0–20M
requests / day
PayPal C++→Go migration · p99 held steady
0–25M+
monthly volume (USD)
on-chain trading platform
~0%
p95 API latency cut
query restructuring · N+1 · Redis
<0ms
time-to-first-token
streaming inference gateway
<0ms
p99 vector search
live traffic · in-memory cache
0.00+
recall@10
~100K-document corpora · HNSW
06 — Toolchain

Each tool earns its place.

Rust

tokio async, lock-free concurrency, zero-copy

Go

goroutines + bounded channels for backpressure

C / C++

performance-critical, low-latency frame paths

Python

the ML boundary — model integration

TypeScript

product surface, real-time trading UIs

PostgreSQL

system of record, hybrid stores

Redis

hot-read cache, embedding cache

Docker

reproducible builds & serving

Kubernetes

orchestration for AI workloads

AWS

distributed systems infra

gRPC / GraphQL

service + product APIs

Anthropic / OpenAI

LLM orchestration & tool-use

ONNX

runtime for on-device inference

Rust

tokio async, lock-free concurrency, zero-copy

Go

goroutines + bounded channels for backpressure

C / C++

performance-critical, low-latency frame paths

Python

the ML boundary — model integration

TypeScript

product surface, real-time trading UIs

PostgreSQL

system of record, hybrid stores

Redis

hot-read cache, embedding cache

Docker

reproducible builds & serving

Kubernetes

orchestration for AI workloads

AWS

distributed systems infra

gRPC / GraphQL

service + product APIs

Anthropic / OpenAI

LLM orchestration & tool-use

ONNX

runtime for on-device inference

drag to explore

07 — Open Source
Taurigithub.com/tauri-apps/tauri

A memory leak, fixed at the ObjC boundary.

Core contributor — Rust framework for cross-platform desktop apps. A specific, verifiable fix — merged upstream as PR #15224.
tauri-runtime-wry · leak fix
the leaktauri-runtime-wry — WithWebview leaked Objective-C retains on macOS/iOS
the fixreplaced Retained::into_raw() with scoped Retained via Retained::as_ptr()
whykeeps ObjC retain/release balanced — WebContent processes no longer kept alive for the whole app lifetime
the proofRSS stabilized 116.5116.9 MB over a 3-min stress loop
shippedPR #15224, merged upstream
08 — The path here

Five years, reverse-chronological.

  1. Present

    AI/ML Engineer

    · Turing
    Remote · AI/ML & agentic systems for clients incl. Anthropic and OpenAI

    Building agentic AI/ML systems for frontier labs — LLM orchestration, tool-use & function calling, and multi-step reasoning pipelines, plus inference optimization and the MLOps to ship them. Perf-critical infra in Rust/C++, Python at the ML boundary.

  2. Present

    AI/ML Engineer

    · Crossing Hurdles
    Remote · production AI for clients incl. Auth0 and Handshake AI

    Streaming inference gateway with concurrent LLM fan-out; TTFT under 300ms, vector search under 50ms p99, hardened in Rust with backpressure.

  3. Apr–Jun

    AI/ML Engineer (Contract)

    · Legal RAG Platform
    Remote · retrieval-augmented legal information system

    PDF → semantic chunking → hybrid vector+keyword store → reranking → cited answers, with vision-LLM ingestion and an autonomous re-indexing agent.

  4. Apr–Jul

    AI Engineer

    · BlockStars
    Freelance / Remote · computer-vision + LLM reasoning

    Video-based LLM parser: live video → YOLO detection → structured detections → LLM scene reasoning, in C++/Rust/Python.

  5. Oct–Dec

    Senior Rust Engineer

    · Aether
    Contract · on-device retrieval & vector search

    Privacy-first AI desktop agent: local semantic engine, on-device embeddings, HNSW retrieval, macOS/Linux binaries idling under 50MB.

  6. Dec–May

    Senior Software Engineer (External Contract)

    · PayPal
    High-throughput backend migration

    Migrated C++ services to Go on a 15–20M req/day tier, p99 held, zero-downtime cutover via gradual traffic shifting.

  7. Mar–Oct

    Software Engineer (Confidential)

    · Trading Platform
    On-chain trading infrastructure

    20–25M+ monthly volume: real-time feeds, sub-second Rust swap execution, wallet/whale tracking, Next.js order books.

  8. Feb–Sep

    Senior Full-Stack Engineer

    · PrivateFirm
    Full-stack web across multiple product surfaces

    Next.js/React/Go/Python/Node. Cut p95 API latency ~40% via query restructuring, N+1 elimination, and Redis hot-read cache.

  9. Earlier

    ~4 years · ~10 contracts

    · Earlier
    Mobile · full-stack web · blockchain

    Production mobile (Flutter, React Native), full-stack web (Next.js, React, Node.js), and blockchain systems (Solidity, Solana/Anchor).

Ship the reasoning. Ship the runtime.

One engineer. Full stack, down to the systems layer.