levelscorner · engineering with proof

I build backend platforms, agentic AI systems, and reliable infrastructure for high-consequence software.

From telecom signaling and humanoid robotics to Go microservices and agentic AI, I work on systems that need strong contracts, clear orchestration, and operational sanity when the edges get messy.

Currently leading AI-native platform work at Persistent Systems across agentic support, backend platforms, and production-grade execution flows.

View selected workDownload resumeStart a conversation
Current angleOpen to senior backend / AI platform roles

What I optimize for

Durable systems, clear contracts, useful tooling, and operational calm when a feature stops being a demo.

  • Agentic support systems with RAG, tools, and escalation boundaries
  • Go backend platforms across provisioning, subscriptions, and developer workflows
  • Systems thinking shaped by telecom, robotics, and real production constraints

8+

years across systems, backend, and AI

Go · Python · C++

core languages across current and foundational work

Microservices → Agents

depth from service contracts to LLM orchestration

0 → prod

comfortable owning design, delivery, and rollout

Selected work

Proof before personality.

See all projects
Professional / Agentic AI

Recipe support agent · Intuit

Designed and built an agentic Slack support bot for Recipe, Intuit's data curation and developer platform. It answers from a RAG knowledge base first, then investigates with tools when evidence is missing.

  • LangChain orchestration loop with Claude via Intuit GenOS and SageMaker
  • Custom MCP server exposing internal diagnostics and support actions as tools
  • RAG over code, docs, Slack history, meeting transcripts, and runbooks
PythonLangChainClaudeMCPRAGSlack
Personal / Agent platform

Clotho

Greenfield multi-tenant agent platform built around compiled-plan orchestration: an LLM plans a typed execution graph and a deterministic interpreter runs it with human approval before execution.

  • pgvector memory with secret-redaction before embedding and per-tenant retrieval
  • BYOK AES-256-GCM credential vault and multi-provider LLM routing
  • Durable execution and human-in-the-loop control via Hatchet
GopgvectorHatchetAES-GCMPostgres
Personal / Creative AI system

chotu.studio / auto-shorts

AI studio that turns a creative brief into a finished short through a seven-stage orchestrated DAG covering story, characters, cinematography, frames, motion, audio, and assembly.

  • Durable run-ledger for crash recovery without double-billing
  • Multi-provider generative-media integration behind a unified adapter
  • Per-run cost and latency metering
PythonFastAPIReactMCPClaude

Core strengths

Three lanes I keep coming back to.

Agentic AI systems

I care about the non-demo parts: tool contracts, retrieval quality, escalation boundaries, durable execution, and keeping LLM workflows inspectable when reality gets noisy.

  • Multi-agent orchestration and planning loops
  • RAG, tool use, MCP servers, and agent memory
  • Production concerns: latency, cost, observability, and safe fallbacks

Backend platforms

Most of my work lives where system contracts matter. I like service boundaries, operational clarity, and data flows that remain boring in production.

  • Go microservices, gRPC, REST, GraphQL, and event-driven systems
  • Schema discipline, migrations, rollout safety, and production validation
  • Platform work spanning provisioning, subscription lifecycle, and developer tooling

Systems thinking

I started close to the wire in telecom and robotics. That background still shapes how I approach correctness, performance, and the cost of vague abstractions.

  • C++ systems foundations and packet-level thinking
  • Hardware-aware robotics control and real-world constraints
  • Preference for clarity over magic in architecture and implementation

Writing direction

What I think about when building AI and backend systems.

Read notes
Field note

Why most internal AI support bots fail after the demo

The problem is usually not the model. It is weak retrieval, shallow tool contracts, and no disciplined escalation boundary when the bot leaves the happy path.

  • Answer from evidence first, not from vibes
  • Treat tools as product surfaces with contracts, retries, and observability
  • Escalation is a design feature, not an admission of failure
Field note

What migrating backend services to Go actually buys you

The win is rarely just throughput. The bigger gain is simpler operational behavior, clearer ownership, and a codebase the team can reason about during incidents.

  • Reduce moving parts before you benchmark hero numbers
  • Migration succeeds when API edges and rollout plans are boring
  • Operational confidence matters as much as language preference
Field note

Building agent platforms without lying to yourself

If the plan is fuzzy, the execution graph should not be. Typed interfaces, durable state, and explicit human checkpoints are what make agent systems trustworthy.

  • Use typed execution units where possible
  • Persist enough state to recover without duplicated side effects
  • Keep humans in the loop where cost or risk is asymmetric

Available

Open to senior backend, platform, and agentic AI engineering conversations.

If you need someone who can reason across backend systems, platform design, and agentic AI execution, let's talk.

Contact meGrab the resume