╔══════════════════════════════════════════════════════════════════╗
║ ║
║ 🧠 Agent Architect · 🔧 MLOps Engineer · 🔬 First Principles ║
║ ║
║ Building AI systems that think, see, and ship. ║
║ ║
╚══════════════════════════════════════════════════════════════════╝
Most people use AI. I build the systems that make AI work.
Every project I ship follows one rule: understand from first principles, then build from scratch. No LangChain. No LangGraph. No magic abstractions. Just Python, clear architecture, and hard-won intuition about what actually matters in production.
What I've built in 2026:
├── 18 AI agent sessions (perception → memory → decision → action)
├── A multimodal vision-language model (Gemma-270M + CLIP, trained from scratch)
├── ResNet-50 on ImageNet with multi-GPU DDP (one of ~10K people who've done this)
├── A screenshot-to-website AI pipeline (6 agents, real-time WebSocket UI)
└── Production LLMOps infrastructure (FastAPI → Docker → K8s → Prometheus)
I don't use agent frameworks. I build the framework. 18 sessions of progressively complex agent systems, each one teaching a different architectural pattern. Agent Architecture:
├── Perception (Gemini Vision + structured extraction)
├── Memory (session logs + vector search + summarization)
├── Decision (multi-step planning with tool selection)
└── Action (MCP servers + sandboxed execution)Key insight: An agent is just a while loop with good memory. Everything else is engineering. |
Built a complete vision-language model from scratch. Combined a 270M language model with CLIP vision encoder, trained on 157K LLaVA pairs on a single A100. |
Not Philosophy: If you can't build it from scratch, you don't understand it. |
Complete production pipeline: FastAPI serving → Docker containerization → K8s orchestration → Prometheus monitoring → rate limiting → cost controls. Principle: You can't optimize what you can't measure. |
| Domain | Technologies |
|---|---|
| 🤖 Agent Architecture | Custom Cognitive Loops MCP Servers Structured Reasoning Tool Orchestration |
| 🧠 ML / Deep Learning | PyTorch Transformers CLIP LoRA/PEFT Mixed Precision DDP |
| 💬 LLM APIs | Gemini GPT Claude Ollama vLLM |
| 🔧 MLOps | Docker Kubernetes DVC MLflow W&B Prometheus Grafana |
| ☁️ Cloud & Infra | AWS (EC2/Lambda/EKS) HuggingFace Spaces Render |
| 💾 Data & Storage | FAISS Pinecone PostgreSQL Redis Vector DBs |
| 🌐 Web | FastAPI WebSockets React Gradio |
┌────────────────────────────────────────────────────────────────────────┐
│ │
│ 📚 Training Models from Scratch │
│ ├── Understanding every gradient, every weight update │
│ ├── CUDA optimization & GPU computing fundamentals │
│ └── Making deep learning "go brrrr" from first principles │
│ │
│ 🏗️ Building AI Agents │
│ ├── Perception → Memory → Decision → Action loops │
│ ├── Tool use & MCP server architecture │
│ └── Cognitive monitoring & memory versioning │
│ │
│ ⚙️ Production MLOps → AgentOps │
│ ├── Config-driven architecture (behavior via YAML, not code) │
│ ├── Unified infra for traditional models + autonomous agents │
│ └── Same production rigor for reasoning as predictions │
│ │
└────────────────────────────────────────────────────────────────────────┘
I write deep technical blogs — no fluff, just working code and hard-won lessons.
| Blog | Topic | What You'll Learn |
|---|---|---|
| Agentic AI from First Principles | Agent Architecture | 4-layer cognitive stack, tool use, multi-agent systems — all in Python |
| LLMOps: Deploy & Scale LLMs | Production AI | FastAPI → Docker → K8s → Prometheus, every line explained |
| Training ResNet from Scratch | Deep Learning | Architecture → implementation → One Cycle Policy → multi-GPU DDP |
| Building a Multimodal VLM | Multimodal AI | CLIP + Gemma-270M + LoRA, trained on 157K pairs with full MLOps CI/CD |
class AgentArchitect:
"""The principles behind everything I build."""
principles = {
"first_principles": "If you can't build it from scratch, you don't understand it",
"no_magic": "No LangChain, no LangGraph — just Python and clear thinking",
"production_or_bust": "A model in a notebook is a toy. Ship it or it doesn't count",
"measure_everything": "Prometheus for predictions AND cognitive load",
"config_over_code": "Change behavior via YAML, not rewrites",
"small_teaches_big": "A 270M model teaches the same architecture as a 70B one",
}
def build(self, idea):
"""The loop: understand → implement → ship → write about it."""
understanding = self.study_from_first_principles(idea)
implementation = self.build_from_scratch(understanding)
production = self.deploy_with_monitoring(implementation)
return self.write_the_blog(production) # so others can learn too
⚡ Like training a neural network — each epoch brings us closer to autonomous systems 🧠
Building the bridge between deep learning fundamentals and production AI systems.
If you're training models from scratch, building agents without frameworks, or shipping ML to production — let's talk!
