I'm a software engineer exploring the intersection of AI Agents, Developer Infrastructure, Distributed Systems, and Generative AI.

Currently building autonomous software engineering systems — agents that can plan, write code, run experiments, verify results, learn from execution, and keep working on long-running tasks.

                    AUTONOMOUS SOFTWARE ENGINEERING

      ┌──────────┐     ┌──────────┐     ┌──────────┐
      │  PLAN    │ ──▶ │  EXECUTE │ ──▶ │  VERIFY  │
      └──────────┘     └──────────┘     └──────────┘
            ▲                                  │
            │                                  ▼
      ┌──────────┐     ┌──────────┐     ┌──────────┐
      │  MEMORY  │ ◀── │  LEARN   │ ◀── │  EVALUATE│
      └──────────┘     └──────────┘     └──────────┘

My current interests:

AI Agents · Coding Agents · Agent Harnesses · Long-Horizon Tasks
Context Engineering · Agent Memory · Multi-Agent Systems
Durable Execution · AI Infrastructure · GPU / Inference Optimization

A durable runtime for long-running AI agents.

Exploring what happens when an AI agent is treated less like a chatbot and more like a persistent software process.

Planning · Memory · Subagents · Durable Execution · Sandboxing · MCP · A2A · Evals

The bigger idea:

Give agents the infrastructure required to work autonomously for hours, days, or longer — without losing state, context, or control.

• Can coding agents reliably handle 100+ step software engineering tasks?
• What does the OS for autonomous agents look like?
• How should agents manage context across millions of tokens?
• Can agents learn reusable engineering knowledge from previous executions?
• What is the right architecture for persistent agent memory?
• How do we evaluate agents on real software outcomes, rather than benchmark scores?
• Can autonomous software delivery become a production system rather than a developer experiment?

LLMs PyTorch Transformers Diffusers RAG Vision Multimodal AI

Agent Runtimes MCP A2A Multi-Agent Systems Memory Evals Sandboxing

Java Python Go C++ Quarkus Spring Boot FastAPI

Kubernetes Docker Kafka Redis PostgreSQL ClickHouse Terraform Azure

AI Agents
    ├── Long-Horizon Execution
    ├── Context Engineering
    ├── Persistent Memory
    ├── Multi-Agent Collaboration
    └── Agent Evaluation

AI Infrastructure
    ├── Durable Execution
    ├── Model Serving
    ├── Inference Optimization
    ├── GPU Computing
    └── Distributed Systems

Autonomous Software Engineering
    ├── Coding Agents
    ├── Code Intelligence
    ├── Code Graphs
    ├── Agent Harnesses
    └── Autonomous Delivery

What happens when software engineers stop writing every step — and start designing systems that can figure out the steps themselves?

Build → Break → Learn → Repeat