rust freak | One piece addict 💀 | NIT NGP CS'28
India
Joined February 2025
- Tweets4K
- Following759
- Followers553
- Likes9.8K
Pinned Tweet
f*ck it
I am building clash royale in rust form scratch
currently building the game env
using bevy
will post everyday my progress and journey
documenting the whole precess in md files
Parth Agrawal retweeted
Why can an LLM write code but not count the r's in "strawberry"?
Article 2 of my GenAI + Agentic AI series is live: what tokens are, how BPE builds them, why context windows fill up, and how tokens drive your bill.
Explained in plain words
Parth Agrawal retweeted
Many of you guys dmed that it's very hard to read the roadmap and i should change the approach of posting the roadmap so i made this
HERE IS THE ROADMAPFOR AI AGENT DEVELOPMENT
AI AGENT DEVELOPMENT ROADMAP
AI AGENT DEVELOPMENT ROADMAP
│
├── 1. Programming & Computer Science Fundamentals
│ ├── Python
│ │ ├── Variables & Data Types
│ │ ├── Functions & Modules
│ │ ├── OOP & Exception Handling
│ │ ├── List & Dictionary Comprehensions
│ │ ├── Iterators & Generators
│ │ ├── Decorators & Context Managers
│ │ ├── Asyncio & Await
│ │ ├── Multithreading & Multiprocessing
│ │ └── Type Hints & Pydantic
│ ├── JavaScript / TypeScript Fundamentals
│ ├── Data Structures & Algorithms
│ ├── Git & GitHub
│ ├── Linux & Command Line
│ ├── HTTP & Networking Fundamentals
│ ├── REST APIs
│ ├── JSON & Data Serialization
│ ├── Concurrency & Asynchronous Programming
│ └── Debugging & Logging
│
├── 2. Mathematics & AI Fundamentals
│ ├── Linear Algebra
│ │ ├── Vectors & Matrices
│ │ ├── Matrix Multiplication
│ │ ├── Dot Products
│ │ └── Eigenvalues & Eigenvectors
│ ├── Probability & Statistics
│ │ ├── Probability Distributions
│ │ ├── Conditional Probability
│ │ ├── Bayes' Theorem
│ │ └── Statistical Inference
│ ├── Calculus Fundamentals
│ ├── Optimization
│ ├── Machine Learning Fundamentals
│ ├── Neural Network Fundamentals
│ ├── Deep Learning Basics
│ └── Transformer Architecture
│
├── 3. Large Language Model Fundamentals
│ ├── What Are LLMs?
│ ├── Transformer Architecture
│ │ ├── Encoder & Decoder
│ │ ├── Self-Attention
│ │ ├── Multi-Head Attention
│ │ ├── Positional Encoding
│ │ ├── Feed-Forward Networks
│ │ └── Layer Normalization
│ ├── Tokenization
│ ├── Embeddings
│ ├── Context Windows
│ ├── Pretraining & Fine-Tuning
│ ├── Instruction Tuning
│ ├── RLHF & DPO Fundamentals
│ ├── Inference Fundamentals
│ ├── Temperature & Sampling
│ ├── Top-K & Top-P Sampling
│ ├── Structured Outputs
│ ├── JSON Mode
│ └── Model Limitations & Hallucinations
│
├── 4. LLM APIs & Model Integration
│ ├── OpenAI API
│ ├── Anthropic API
│ ├── Google Gemini API
│ ├── Open-Weight Models
│ │ ├── Llama
│ │ ├── Qwen
│ │ ├── DeepSeek
│ │ └── Mistral
│ ├── Hugging Face
│ ├── Ollama
│ ├── vLLM
│ ├── Model Parameters
│ ├── Streaming Responses
│ ├── Function Calling
│ ├── Tool Calling
│ ├── Structured Generation
│ ├── Model Routing
│ ├── Fallback Models
│ ├── Rate Limits & Retries
│ └── API Cost Management
│
├── 5. Prompt & Context Engineering
│ ├── Prompt Engineering Fundamentals
│ ├── System & Developer Instructions
│ ├── User & Assistant Message Roles
│ ├── Zero-Shot & Few-Shot Prompting
│ ├── Chain-of-Thought Fundamentals
│ ├── Prompt Templates
│ ├── Structured Prompting
│ ├── Context Engineering
│ ├── Context Window Management
│ ├── Context Compression
│ ├── Context Selection & Prioritization
│ ├── Prompt Versioning
│ ├── Prompt Injection Awareness
│ ├── Prompt Caching
│ ├── Semantic Caching
│ └── Context Isolation
│
├── 6. AI Agent Fundamentals
│ ├── What Is an AI Agent?
│ ├── LLMs vs AI Agents
│ ├── Agents vs Workflows
│ ├── Agent Architecture
│ ├── Agent Execution Loop
│ ├── Observe-Think-Act Pattern
│ ├── ReAct Architecture
│ ├── Goal-Oriented Agents
│ ├── Autonomous vs Human-Guided Agents
│ ├── Agent State Management
│ ├── Agent Instructions
│ ├── Agent Planning
│ ├── Task Decomposition
│ ├── Tool Selection
│ ├── Tool Execution
│ ├── Reflection & Self-Correction
│ ├── Stop Conditions
│ └── Agent Failure Modes
│
├── 7. Tool Calling & Function Execution
│ ├── Function Calling Fundamentals
│ ├── Tool Definitions & Schemas
│ ├── JSON Schema
│ ├── Pydantic Validation
│ ├── Tool Selection & Routing
│ ├── Tool Execution Lifecycle
│ ├── Tool Result Handling
│ ├── Parallel Tool Calling
│ ├── Sequential Tool Calling
│ ├── Tool Error Handling
│ ├── Tool Retries & Timeouts
│ ├── Idempotent Tool Execution
│ ├── Tool Permissions
│ ├── Human Approval for Actions
│ ├── Tool Sandboxing
│ └── Custom Tool Development
│
├── 8. Agent Frameworks & SDKs
│ ├── OpenAI Agents SDK
│ │ ├── Agents
│ │ ├── Instructions
│ │ ├── Tools
│ │ ├── Handoffs
│ │ ├── Guardrails
│ │ └── Tracing
│ ├── LangChain
│ ├── LangGraph
│ │ ├── StateGraph
│ │ ├── Nodes & Edges
│ │ ├── Conditional Routing
│ │ ├── Checkpointing
│ │ ├── Interrupts
│ │ └── Human-in-the-Loop
│ ├── LlamaIndex
│ ├── Pydantic AI
│ ├── CrewAI
│ ├── AutoGen
│ ├── Google ADK
│ ├── Semantic Kernel
│ ├── DSPy
│ └── Framework Selection & Tradeoffs
│
├── 9. Agent Memory Systems
│ ├── Memory Fundamentals
│ ├── Short-Term Memory
│ ├── Long-Term Memory
│ ├── Working Memory
│ ├── Episodic Memory
│ ├── Semantic Memory
│ ├── Procedural Memory
│ ├── Conversation History
│ ├── Memory Storage & Retrieval
│ ├── Memory Summarization
│ ├── Memory Compression
│ ├── Memory Retrieval Strategies
│ ├── User Preference Memory
│ ├── Memory Expiration & TTL
│ ├── Memory Isolation
│ ├── Memory Consistency
│ └── Memory Evaluation
│
├── 10. Retrieval-Augmented Generation (RAG)
│ ├── RAG Fundamentals
│ ├── Document Ingestion
│ ├── Document Parsing
│ ├── Text Chunking Strategies
│ ├── Embedding Models
│ ├── Vector Representations
│ ├── Vector Databases
│ │ ├── Pinecone
│ │ ├── Qdrant
│ │ ├── Weaviate
│ │ ├── Chroma
│ │ └── Milvus
│ ├── Similarity Search
│ ├── Metadata Filtering
│ ├── Hybrid Search
│ ├── BM25 Retrieval
│ ├── Reranking Models
│ ├── Query Rewriting
│ ├── Contextual Retrieval
│ ├── GraphRAG
│ ├── Agentic RAG
│ ├── Multimodal RAG
│ ├── Retrieval Evaluation
│ └── RAG Performance Optimization
│
├── 11. Agent Planning & Reasoning
│ ├── Task Planning
│ ├── Task Decomposition
│ ├── Planning Algorithms
│ ├── ReAct
│ ├── Plan-and-Execute
│ ├── Reflection Patterns
│ ├── Self-Correction
│ ├── LLM-Based Planning
│ ├── Hierarchical Planning
│ ├── Goal Decomposition
│ ├── Dependency Management
│ ├── Dynamic Task Replanning
│ ├── Decision Making
│ ├── Reasoning Under Uncertainty
│ ├── Verification Loops
│ └── Planning Failure Recovery
│
├── 12. Multi-Agent Systems
│ ├── Single-Agent vs Multi-Agent Systems
│ ├── Multi-Agent Architecture
│ ├── Agent Orchestration
│ ├── Agent Communication
│ ├── Agent Handoffs
│ ├── Shared State Management
│ ├── Role-Based Agents
│ ├── Supervisor Architecture
│ ├── Hierarchical Multi-Agent Systems
│ ├── Collaborative Agents
│ ├── Competitive Agents
│ ├── Debate-Based Agents
│ ├── Parallel Agent Execution
│ ├── Agent Coordination
│ ├── Conflict Resolution
│ ├── Agent Delegation
│ ├── Agent Isolation
│ └── Multi-Agent Failure Handling
│
├── 13. Model Context Protocol (MCP)
│ ├── MCP Fundamentals
│ ├── MCP Architecture
│ ├── MCP Hosts, Clients & Servers
│ ├── JSON-RPC Communication
│ ├── MCP Transports
│ ├── Tools
│ ├── Resources
│ ├── Prompts
│ ├── Sampling
│ ├── Roots & Context
│ ├── Tool Discovery
│ ├── MCP Server Development
│ ├── MCP Client Development
│ ├── Authentication & Authorization
│ ├── MCP Security
│ ├── MCP Testing
│ └── MCP Production Deployment
│
├── 14. Agent-to-Agent (A2A) Communication
│ ├── A2A Fundamentals
│ ├── Agent Discovery
│ ├── Agent Cards
│ ├── Agent Communication Protocols
│ ├── Task Lifecycle
│ ├── Message Exchange
│ ├── Agent Delegation
│ ├── Multi-Agent Interoperability
│ ├── Authentication & Authorization
│ ├── Streaming & Async Tasks
│ ├── Agent Capability Discovery
│ └── MCP vs A2A
│
├── 15. Agentic Workflow Automation
│ ├── Workflow Fundamentals
│ ├── Sequential Workflows
│ ├── Parallel Workflows
│ ├── Conditional Workflows
│ ├── Loop-Based Workflows
│ ├── State Machines
│ ├── DAG-Based Execution
│ ├── Workflow Orchestration
│ ├── Checkpointing & Resumability
│ ├── Durable Execution
│ ├── Human Approval Workflows
│ ├── Long-Running Tasks
│ ├── Retry & Compensation Logic
│ ├── Workflow Scheduling
│ └── Temporal
│
├── 16. Browser & Computer-Use Agents
│ ├── Browser Automation Fundamentals
│ ├── Playwright
│ ├── Puppeteer
│ ├── Browser DOM Interaction
│ ├── Web Navigation
│ ├── Form Automation
│ ├── Screenshot-Based Interaction
│ ├── Vision-Based UI Understanding
│ ├── Computer Use APIs
│ ├── Desktop Automation
│ ├── Accessibility Tree Interaction
│ ├── Browser Session Management
│ ├── Authentication & Cookies
│ ├── CAPTCHA & Anti-Bot Limitations
│ ├── Browser Sandboxing
│ └── Safe Action Execution
│
├── 17. Coding & Software Engineering Agents
│ ├── Code Generation
│ ├── Code Understanding
│ ├── Repository Exploration
│ ├── Code Search & Navigation
│ ├── Code Editing
│ ├── Multi-File Refactoring
│ ├── Terminal & Shell Execution
│ ├── Test Generation
│ ├── Debugging Agents
│ ├── Code Review Agents
│ ├── Git & GitHub Integration
│ ├── Pull Request Automation
│ ├── Software Development Agents
│ ├── SWE-Bench Fundamentals
│ ├── Execution Sandboxes
│ └── Coding Agent Evaluation
│
├── 18. Multimodal AI Agents
│ ├── Multimodal AI Fundamentals
│ ├── Vision-Language Models
│ ├── Image Understanding
│ ├── Image Processing
│ ├── Audio Understanding
│ ├── Speech-to-Text
│ ├── Text-to-Speech
│ ├── Real-Time Voice Agents
│ ├── Video Understanding
│ ├── Document Understanding
│ ├── OCR & Document Parsing
│ ├── Visual Tool Calling
│ ├── Multimodal Memory
│ ├── Multimodal RAG
│ └── Real-Time Multimodal Interaction
│
├── 19. Agent Evaluation & Testing
│ ├── Evaluation Fundamentals
│ ├── Agent-Level Evaluation
│ ├── Task Success Rate
│ ├── Tool Selection Accuracy
│ ├── Tool Execution Success
│ ├── Reasoning & Planning Evaluation
│ ├── Response Quality Evaluation
│ ├── Retrieval Evaluation
│ ├── Memory Evaluation
│ ├── Trajectory Evaluation
│ ├── LLM-as-a-Judge
│ ├── Human Evaluation
│ ├── Golden Datasets
│ ├── Synthetic Test Data
│ ├── Regression Testing
│ ├── Adversarial Testing
│ ├── Benchmarking
│ ├── A/B Testing
│ └── Production Trace Analysis
│
├── 20. Agent Security & Guardrails
│ ├── OWASP Top 10 for LLM Applications
│ ├── Prompt Injection
│ ├── Indirect Prompt Injection
│ ├── Jailbreak Attacks
│ ├── Data Leakage
│ ├── Sensitive Data Exposure
│ ├── Tool Abuse Prevention
│ ├── Input & Output Validation
│ ├── Policy Enforcement
│ ├── Guardrails
│ ├── PII Detection & Redaction
│ ├── Permission Boundaries
│ ├── Human-in-the-Loop Approval
│ ├── Sandboxed Execution
│ ├── Least Privilege Access
│ ├── Audit Trails
│ ├── Agent Identity & Trust
│ └── Secure Agent Deployment
│
├── 21. Agent Observability & Monitoring
│ ├── Agent Tracing
│ ├── Execution Traces
│ ├── Tool Call Monitoring
│ ├── Token Usage Tracking
│ ├── Latency Monitoring
│ ├── Cost Monitoring
│ ├── Failure Analysis
│ ├── OpenTelemetry
│ ├── LangSmith
│ ├── Langfuse
│ ├── Arize Phoenix
│ ├── AgentOps
│ ├── Prompt Version Tracking
│ ├── Distributed Tracing
│ ├── Production Alerts
│ └── Agent Performance Dashboards
│
├── 22. Agent Infrastructure & Deployment
│ ├── Backend Development
│ │ ├── FastAPI
│ │ ├── Flask
│ │ ├── Node.js
│ │ └── REST & WebSocket APIs
│ ├── Database Systems
│ │ ├── PostgreSQL
│ │ ├── MongoDB
│ │ ├── Redis
│ │ └── Vector Databases
│ ├── Docker & Containerization
│ ├── Kubernetes
│ ├── Cloud Platforms
│ │ ├── AWS
│ │ ├── Google Cloud
│ │ └── Microsoft Azure
│ ├── Serverless Deployment
│ ├── CI/CD Pipelines
│ ├── Background Workers
│ ├── Message Queues
│ ├── Job Scheduling
│ ├── Model Serving
│ ├── GPU Infrastructure
│ ├── Autoscaling
│ ├── Secrets Management
│ ├── High Availability
│ └── Production Cost Optimization
│
├── 23. Advanced AI Agent Engineering
│ ├── Harness Engineering
│ ├── Context Engineering
│ ├── Agent Runtime Architecture
│ ├── Agent State Persistence
│ ├── Durable Agent Execution
│ ├── Long-Horizon Task Execution
│ ├── Dynamic Tool Discovery
│ ├── Agent Self-Improvement
│ ├── Agent Sandboxing
│ ├── Model Routing & Fallbacks
│ ├── Prompt Caching vs Semantic Caching
│ ├── KV Cache Fundamentals
│ ├── Prefill vs Decode Latency
│ ├── Continuous Batching
│ ├── Speculative Decoding
│ ├── Quantization & Distillation
│ ├── Inference Optimization
│ ├── Agent Memory Optimization
│ ├── Multi-Agent Scaling
│ ├── Agent Reliability Engineering
│ └── Agent System Design Tradeoffs
│
├── 24. Build Real-World AI Agent Projects
│ ├── Basic AI Chatbot
│ ├── Tool-Calling AI Assistant
│ ├── Personal Memory Agent
│ ├── Research & Web Search Agent
│ ├── PDF Research Agent
│ ├── RAG-Based Knowledge Assistant
│ ├── SQL Database Agent
│ ├── Customer Support Agent
│ ├── Email Management Agent
│ ├── Browser Automation Agent
│ ├── AI Coding Assistant
│ ├── GitHub Repository Analysis Agent
│ ├── Multi-Agent Research System
│ ├── AI Sales & Lead Generation Agent
│ ├── Financial Data Analysis Agent
│ ├── Voice-Based AI Assistant
│ ├── Autonomous Workflow Automation System
│ ├── Multi-Agent SaaS Platform
│ └── Production-Ready AI Agent Platform
│
└── 25. Career Preparation & Engineering Mastery
├── Master Python & Async Programming
├── Understand LLM Internals
├── Build Agents Without Frameworks
├── Master Tool Calling & Orchestration
├── Learn RAG & Memory Architecture
├── Understand Multi-Agent Systems
├── Master MCP & A2A Protocols
├── Learn Agent Evaluation & Observability
├── Study AI Agent Security
├── Understand Distributed Systems
├── Read AI Research Papers
├── Study Open-Source Agent Frameworks
├── Contribute to Open Source
├── Build Production-Grade Agent Projects
├── Write Technical Articles
├── Build in Public
├── Study Real-World Agent Architectures
├── Practice AI Engineering Interviews
└── Build a Strong GitHub Portfolio
FINAL GOAL:
Become a Production-Ready AI Agent Engineer
Parth Agrawal retweeted
Stop starting from scratch.
Introducing palletism.art
A curated library of taste packs with reference images, design inspiration, color palettes and fonts, all ready for your agents via MCP.
Parth Agrawal retweeted
As an AI Engineer, don't just learn how to build AI agents. Learn how to make them reliable.
Here are 15 things you should understand before shipping agents to production:
1. Tool orchestration: How to coordinate multiple tools, APIs, and models without creating unnecessary complexity.
2. State management: How to maintain conversation state, task progress, and intermediate results across multiple agent steps.
3. Memory architecture: Short-term memory, long-term memory, episodic memory, and when to use each.
4. Planning vs. execution: Separate task decomposition from tool execution instead of letting agents improvise every step.
5. Tool contracts: Define strict input schemas, output formats, validation rules, and failure responses for every tool.
6. Retry strategies: Implement exponential backoff, retry limits, timeouts, and circuit breakers for unreliable dependencies.
7. Idempotency: Prevent duplicate payments, repeated database writes, and unintended side effects when tools are called multiple times.
8. Human-in-the-loop: Know when an agent should pause and request human approval before taking irreversible actions.
9. Agent coordination: Understand supervisor, hierarchical, sequential, and parallel agent architectures.
10. Context management: Control context growth, summarize intermediate results, and preserve important information across long-running tasks.
11. Termination conditions: Define clear stopping criteria, execution budgets, and maximum iteration limits to prevent infinite loops.
12. Permission boundaries: Give agents only the tools and access they need. Never assume an LLM will respect security boundaries on its own.
13. Observability: Trace every model call, tool invocation, state transition, token usage, and execution failure.
14. Agent evaluation: Test task completion, tool selection, argument accuracy, recovery behavior, and consistency across multiple runs.
15. Production resilience: Design fallback models, graceful degradation, failure recovery, and rollback strategies.
Building an agent that works once is easy.
Building one that works reliably across thousands of unpredictable user requests is a completely different engineering problem.
Stop optimizing agents for impressive demos. Start engineering them for production.
Parth Agrawal retweeted
How do you keep up with soo many papers as a general AI engineer who is genuinely curious to learn more
Parth Agrawal retweeted
🚨NVIDIA IS HIRING 🚨
These are some of the open roles:
-CEO — in person Santa Clara, CA ($$$$M- $$$$$M)+ stock
-Anti Chinese Spy Guard — in person Santa Clara, CA ($$M-$$$M)
-Senior Director, Graphics Systems Software — $384,000–$575,000 — Santa Clara, CA
-Director, Server CPU Product Architecture — L5: $288,000–$437,000—Santa Clara, CA / Austin, TX
-Senior Director, Board Product Development Engineering — $332,000–$500,250 — Santa Clara, CA
-Senior Director, Reliability Engineering — $332,000–$500,250 — Santa Clara, CA
-Director, Autonomous Vehicles Platform — $320,000–$488,750 — Santa Clara, CA
-Director, Engineering, Autonomous Vehicles — $320,000–$488,750 — Santa Clara, CA
-Director, FSI Predictive Technology — $320,000–$488,750 — Santa Clara, CA
Apply via Backdoor: textbackdoor.com
Parth Agrawal retweeted
vidya-bodha.com is live.
My GitHub repo crossed 830+ stars, so I turned it into a proper learning website.
70+ in-depth engineering articles, all in one place, organized so you can actually learn instead of scrolling a timeline.
What you’ll find:
-30+ HLD breakdowns (YouTube, Netflix, Spotify, Instagram, Amazon, Discord, and more) -LLD classics like parking lots and vending machines -Backend fundamentals: APIs, databases, caching, concurrency -A complete Distributed Systems series, all 9 parts -A complete Microservices series -Search and filters by topic -Structured learning paths -Progress tracking, so you know what’s done and what’s next
“Vidya” means knowledge and “bodha” means understanding. That’s the goal here: not just reading about systems, but really understanding how they work.
AI, ML, and DevOps content is coming next, and every new article lands on the site first.
The GitHub repo stays open if you’d like to star it
github.com/harshit3011/Techn…