class Aditya:
    def __init__(self):
        self.role     = "Agentic AI Engineer"
        self.base     = "Full-Stack Developer"
        self.i_build  = ["multi-agent systems", "tool-using agents", "the infra around them"]
        self.i_obsess = "reliability and evaluation over flashy demos"
        self.mission  = "give software agents a body in the real world"

    def ship(self):
        return "agents that hold up in production"

I'm an Agentic AI Engineer with a full-stack backbone. I design autonomous, multi-agent systems that plan, reason, and use tools, and I build the infrastructure that makes them real, from the model call all the way to the interface a user touches.

The part I actually care about is the hard part: agents that keep their memory intact across long tasks, tool calls that don't shatter on messy input, and orchestration you can still debug when no two runs behave the same. Anyone can demo an agent that works once. I want to know its measured success rate and why it moved.

Building agents that work. Designing multi-agent systems with real memory, planning, and reliable tool use, then wrapping them in full-stack products that ship.

Engineering for production. Treating evaluation, observability, and reliability as first-class, so an agent's behavior is measured and debuggable, not a black box.

Bridging software to the physical world. Deeply interested in embodied AI, taking the orchestration I build in software and giving it a way to act in the real world.

Agentic & LLM Orchestration

Agent SDKs

Core & Infrastructure

Not a wrapper around a model call. A system with a control loop, a memory layer, hardened tools, and a measurement layer that tells me when it degrades.

%%{init: {'theme':'base','themeVariables':{'primaryColor':'#161B22','primaryTextColor':'#E6EDF3','primaryBorderColor':'#1F6FEB','lineColor':'#58A6FF','secondaryColor':'#21262D','tertiaryColor':'#0D1117','fontSize':'15px'},'flowchart':{'padding':22,'nodeSpacing':70,'rankSpacing':95,'curve':'basis'}}}%%
flowchart LR
    U([User Goal]) --> P[Planner<br/>decompose into subgoals]
    P --> R{{Reasoning Loop}}
    R -->|select| T[Tool Layer<br/>validated schemas]
    T -->|result| O[Observation<br/>verify and ground]
    O -->|replan on failure| R
    R -->|task complete| A([Answer / Action])

    M[(Memory<br/>working - episodic - semantic)] <--> R
    G[Guardrails<br/>scoped permissions] --- T
    E[Eval and Observability<br/>traces - success rate - cost] -.-> R
    E -.-> T
    E -.-> A

    style U fill:#1F6FEB,stroke:#1F6FEB,color:#fff
    style A fill:#1F6FEB,stroke:#1F6FEB,color:#fff
    style R fill:#21262D,stroke:#58A6FF,color:#E6EDF3
    style E fill:#161B22,stroke:#8B949E,color:#8B949E
    style G fill:#161B22,stroke:#8B949E,color:#8B949E
    style M fill:#161B22,stroke:#58A6FF,color:#E6EDF3

The two boxes most people skip are the two I refuse to: guardrails on the tool layer, and eval plus observability wrapping the whole loop. An agent you cannot measure is an agent you cannot improve.

A short explainer of how an end to end agentic system actually runs a task.