AARAV IYER

aarav@walnutlabs:~$ whoami --verbose

Aarav Iyer (14) — Systems Engineer, AI Architect, and Security Researcher.
I build autonomous orchestration engines, highly concurrent distributed systems, and full-stack AI infrastructure. I don't build wrappers; I build the underlying engines that power them. Deeply invested in low-level execution, network protocols, and zero-trust architectures.

>>> ./active_processes/gorilla_builder

Gor://a Builder is an open-source, agentic AI platform designed to automate the generation and deployment of production-ready applications. It bridges the gap between raw LLM output and deployable, stateful architectures.

• Multi-Agent Swarm Orchestration: Implemented a robust architecture where distinct Python agents (Planner, Coder, Reviewer) operate in isolated contexts, passing structured JSON states to prevent hallucination cascades.
• Abstract Syntax Tree (AST) Parsing: Built custom logic to parse and inject code directly into existing file structures rather than rewriting entire files, reducing latency by 70%.
• Zero-Config Pipelines: Integrated native OAuth and deployment Webhooks to push generated codebases directly to production environments.

>>> ./infrastructure/distributed_systems

Engineered highly scaled, real-time communication systems bypassing heavy third-party dependencies.

• Custom WebRTC SFU: Designed a low-latency Selective Forwarding Unit (SFU) architecture to handle massive concurrent audio/video streams without crashing client browsers.
• CRDT State Synchronization: Built robust real-time collaborative engines using Conflict-free Replicated Data Types (CRDTs) to resolve simultaneous document edits across distributed nodes with zero data collision.

>>> ./legacy_binaries

/// AST Mutation Engines: Developed custom Abstract Syntax Tree parsers for deep code injection and dynamic refactoring without breaking syntactic validity.

/// Windy CFD: Engineered a free, open-source Computational Fluid Dynamics web application for online wind analysis.

/// PyTutor AI: Built an open-source, AI-powered Python environment utilizing deterministic execution sandboxes.

>>> ./system_export

EMAIL: Aaravriyer@gmail.com
GITHUB: github.com/aaravriyer193

AGENTS & THE MODEL CONTEXT PROTOCOL

aarav@walnutlabs:~$ tail -f /var/log/swarm_orchestrator.log

The industry is currently obsessed with zero-shot prompting. However, real engineering requires state machines, deterministic fallbacks, and autonomous multi-agent swarms. An agent is not simply a glorified API call; it is a continuously running execution loop that observes, reasons, and acts upon an external environment.

>>> The Model Context Protocol (MCP)

Hardcoding distinct API endpoints into LLM tool-calling logic creates monolithic, unmaintainable codebases. To scale infrastructure, the implementation of the Model Context Protocol (MCP) is paramount. MCP acts as a universal socket for intelligence. Whether an agent needs to read a local file system, query a PostgreSQL database, or trigger a deployment action, MCP standardizes the communication layer so the underlying model can be swapped seamlessly.

# Excerpt: Standardizing Tool Execution via MCP Wrapper
class AutonomousMCPClient:
    def __init__(self, model_router):
        self.router = model_router
        self.registered_tools = {}

    def register_skill(self, name: str, schema: dict, handler):
        # Standardizes input for Claude, GPT-4o, or local SLMs
        self.registered_tools[name] = {
            "schema": schema,
            "execute": handler
        }

    async def dispatch(self, tool_call):
        name = tool_call.get('name')
        args = tool_call.get('arguments')
        if name in self.registered_tools:
            return await self.registered_tools[name]['execute'](**args)
        raise Exception(f"MCP Protocol Error: Tool {name} unhandled.")
            

>>> Swarm Choreography & State Machines

A single LLM degrades rapidly as context length increases. To combat hallucination cascades, Swarm Architecture is deployed. A 'Planner' agent generates a strict JSON dependency graph. A 'Coder' agent reads only one node of the graph at a time, writes the code, and passes it to a 'Reviewer' agent.

If the Reviewer catches a syntax error (via regex or AST parsing), it does not halt the program; it recursively loops back to the Coder with the exact error trace. This deterministic, self-healing loop is what separates a toy application from a production orchestration engine.

>>> Deterministic Execution Enclosures

Never trust an LLM to format data perfectly on the first pass. All critical agent outputs must be wrapped in strict Regex and JSON validation layers. If an agent fails to return a valid structured object after a predefined number of retries, the system must trigger a hardcoded deterministic fallback to prevent entire pipeline failure.

DISTRIBUTED INFRASTRUCTURE & WEB RTC

aarav@walnutlabs:~$ netstat -tulpn | grep node

Modern full-stack engineering isn't about simply writing HTML and CSS; it is about managing state across highly distributed networks, optimizing edge computing latency, and building resilient APIs capable of surviving massive traffic spikes.

>>> WebRTC & High-Concurrency Video

Connecting two users via peer-to-peer (P2P) WebRTC is trivial. However, connecting 1,000 users in a single virtual conference requires a fundamentally different architectural approach. A pure P2P mesh crashes client browsers due to massive O(n^2) bandwidth requirements.

The solution is migrating to a Selective Forwarding Unit (SFU) architecture. The central server ingests a single stream from a client and efficiently broadcasts it to the remaining peers, drastically reducing client-side CPU and bandwidth load.

// Simplified Signaling Server Logic (Node.js/Socket.io)
io.on('connection', (socket) => {
    socket.on('join-room', (roomId, userId) => {
        socket.join(roomId);
        
        // Broadcast to all other clients in the stream
        socket.to(roomId).emit('user-connected', userId);

        // Handle ICE Candidate exchange for NAT traversal
        socket.on('ice-candidate', (candidate, targetId) => {
            io.to(targetId).emit('ice-candidate', candidate, socket.id);
        });

        socket.on('disconnect', () => {
            socket.to(roomId).emit('user-disconnected', userId);
        });
    });
});
            

>>> Real-Time State & CRDTs

To power live collaborative document editors (similar to Google Docs), standard database polling is far too slow and inherently prone to race conditions. The optimal implementation involves WebSocket-based real-time syncing utilizing Conflict-free Replicated Data Types (CRDTs). This algorithm ensures that even if two users edit the exact same sentence simultaneously with 200ms of latency, the document state resolves perfectly mathematically without locking the database row.

>>> Unified Edge Gateways

In highly scaled applications, the frontend should not communicate directly to databases or third-party APIs. Robust infrastructure relies on Unified API Gateways running on edge functions (like Cloudflare Workers). This gateway handles rate limiting, JWT validation, and intelligent traffic routing. If a primary service experiences a timeout, the edge gateway autonomously falls back to a secondary service, ensuring 99.9% uptime for the user without any frontend logic changes.

MACHINE LEARNING & VECTOR MATH

aarav@walnutlabs:~$ python3 ./train_model.py --epochs 1000

Before the current generative AI boom, the foundation of artificial intelligence rested heavily on classical Machine Learning, utilizing TensorFlow, PyTorch, and scikit-learn. Understanding the underlying mathematics of gradient descent, backpropagation, and matrix multiplication is absolutely crucial to leveraging modern Large Language Models effectively.

>>> Retrieval-Augmented Generation (RAG) Pipelines

Fine-tuning a massive LLM is computationally expensive, slow, and inherently static. For applications requiring dynamic, up-to-date knowledge bases, RAG pipelines are engineered. This involves breaking down massive datasets into chunks, converting them into high-dimensional numerical vectors (embeddings), and storing them in vector databases like Pinecone or PostgreSQL equipped with pgvector.

# Mathematical foundation of Vector Similarity Search
import numpy as np

def cosine_similarity(vec_a, vec_b):
    # Calculate the dot product of the two vectors
    dot_product = np.dot(vec_a, vec_b)
    
    # Calculate the L2 norm (magnitude) of each vector
    norm_a = np.linalg.norm(vec_a)
    norm_b = np.linalg.norm(vec_b)
    
    # Prevent division by zero
    if norm_a == 0 or norm_b == 0:
        return 0.0
        
    # Return similarity score (1.0 is identical, 0.0 is orthogonal)
    return dot_product / (norm_a * norm_b)
            

>>> Chunking Strategy & Context Windows

The secret to high-performing RAG is not the underlying language model; it is the chunking strategy. Simply splitting text by arbitrary character counts severs semantic meaning. Deploying Recursive Character Text Splitting with calculated semantic overlap ensures that paragraphs and code blocks remain intact when embedded. This guarantees that when the system retrieves the context, the LLM receives a logically complete thought rather than a fractured sentence.

>>> Small Language Models (SLMs) & Quantization

Relying purely on cloud inference is a massive privacy, security, and latency bottleneck. Advanced research focuses on deploying Small Language Models (7B to 14B parameters) directly to local hardware using inference engines. By utilizing GGUF quantization (converting heavy 16-bit floating-point numbers to 4-bit integers), powerful reasoning engines can run on standard consumer GPUs with minimal precision loss.

SYSTEM EXPLOITATION & ENGINEERING

aarav@walnutlabs:~$ cat /docs/hacker_manifesto.txt

True engineering requires understanding a system so deeply that you can dismantle it, bypass its constraints, and rebuild it to serve a new purpose. The traditional path of learning generic APIs is insufficient; you must learn how the compiler, the runtime, and the network actually operate under the hood.

>>> AST Manipulation & Metaprogramming

You cannot build advanced developer tools by simply stringing together unverified outputs. You must parse the code mathematically. By converting raw strings into Abstract Syntax Trees (ASTs), I engineer systems that can autonomously traverse, mutate, and inject code into deeply nested directories without breaking the syntactic validity of the host application.

>>> Sandboxing & Escape Vectors

Executing untrusted, generated code on bare metal is a critical vulnerability. I architect deterministic execution environments utilizing deeply constrained sandboxes. Understanding the limits of a sandbox is the first step to securing it against escape vectors, arbitrary code execution (ACE), and prototype pollution attacks.

>>> Protocol Reverse Engineering

I do not rely on high-level, bloated libraries when execution performance is critical. Whether it is stripping down WebRTC to its bare ICE candidate exchanges to build a custom SFU, or intercepting raw WebSocket frames to implement proprietary compression algorithms, understanding binary protocols is where actual optimization occurs.