// SOFTWARE ENGINEER · PHOENIX, AZ · SYS.ONLINE

ESVAR KANNAN

I build cloud-native backend systems at Wells Fargo — microservices, Kafka event streams, Azure — and instruments for watching AI agents work: audit middleware for the Model Context Protocol, and a generative portrait rendered from a real multi-agent reasoning trace.

PROC://ESVAR.INIT
$ ./esvar --init
[ok] core   : .NET · Java · Kafka · SQL
[ok] infra  : Azure · K8s · OpenShift
[ok] agents : MCP · Claude API · Copilot
[..] status : accepting_new_missions
$ tail -f swarmcore/trace.json
2+ yrsengineering @ Wells Fargo
100K+statements/day system scale
~50%faster via AI adoption I led
4.0M.S. CS — Arizona State
[01] FEATURED_TRANSMISSION

SWARMCORE

A generative portrait of a multi-agent AI mind — a human face made of live code.

GENERATIVE DATA-ART REAL AGENT TRACE
THE LOOP — THE FACE RESOLVES AS THE AGENTS WORKSTATUS: EXECUTING → AWAITING INPUT → COMPLETE

SWARMCORE is generative data-art built on a real system. A real multi-agent pipeline ran — an orchestrator model split a task into three roles (research, analyze, write), three sub-agents executed it with live tools (web search + a knowledge base), and a human steered one tool call mid-flight. Every step was captured to a trace, which SWARMCORE replays as a human face rendered entirely from a field of monospace characters: the face resolves out of the noise as the agents work, words from the trace drift through the code, and the human-steering moment flushes the whole face amber.

Integrity note — the agent trace is real Anthropic API output. Only the single, clearly-labeled steering moment is staged, and it renders on screen as SIMULATED so it can never be mistaken for the model's own behavior.

The face is made of the run

Not a picture with an overlay — a procedural luminance mask maps per-character brightness on a canvas, so the portrait literally materializes from the swarm's activity.

Replayed, not simulated

Orchestrator planning, sub-agent intents, tool_use blocks, and results are captured verbatim from live API calls and replayed in timestamp order.

The amber moment

When the human-steering checkpoint fires, the entire face flushes amber while a side terminal prints the exact edit — the person inside the loop, made visible.

SWARMCORE wide view — the code-face beside a live agent telemetry terminal
UI + LIVE AGENT-TELEMETRY READOUT — VANILLA JS, NO FRAMEWORKS, RUNS FULLY OFFLINE
JavaScript HTML Canvas Generative Art Anthropic / Claude API Multi-Agent Systems Data Visualization
[02] INFRASTRUCTURE
CI PASSING MIT PYTHON 3.10+

If SWARMCORE is the portrait of agents working, this is the flight recorder.

A transparent middleware proxy for the Model Context Protocol. It sits between any MCP client and any MCP server, forwards every tool call untouched, and records a full audit trail — arguments, response, duration, success/failure — to a local SQLite database. The proxy exposes its own MCP tools, so the agent can query its own call history at runtime.

┌──────────────┐ Streamable HTTP ┌────────────────────┐ stdio / HTTP ┌────────────────┐ │ MCP Client │ ──────────────────▶ │ mcp-audit-logger │ ───────────────▶ │ MCP Server X │ │ (agent/IDE) │ ◀────────────────── │ (this proxy) │ ◀─────────────── │ (real tools) │ └──────────────┘ └─────────┬──────────┘ └────────────────┘ ▼ ┌─────────────┐ │ audit.db │ ← queryable via audit_* tools └─────────────┘

17 audit tools for agents

Connected agents introspect their own history — per-tool stats with p50/p95 latency, error rates, slowest calls, argument search, JSONL/CSV export, retention purge.

7 observability tools

One proxy, four backends: Prometheus, Tempo/Jaeger, AlertManager. obs_investigate fans out across all of them concurrently and returns a structured incident summary.

Zero-ops by design

SQLite in WAL mode — no external DB, nothing to operate. Synthesized /metrics, /healthz for k8s probes, bearer auth, Docker image, full CI.

Python MCP SDK Streamable HTTP SQLite (WAL) Prometheus Tempo / Jaeger Docker pytest · ruff · mypy
[03] MORE_BUILDS

stonks PRIVATE · LIVE

An always-on ecosystem of scheduled AI agents autonomously trading a small, strictly-bounded personal account: an idea-scout hunts candidates across five lanes each morning, an hourly engine manages the book against broker-resident stops, open/close managers bookend the session, and a weekly review grades the process — and evolves its own playbooks inside hard guardrails. Structurally risk-capped: cash account, long-only, no margin, so the worst case is mathematically bounded.

Multi-Agent SystemsMCPScheduled AutomationMarket Data APIsRisk Engineering

resume-copilot PRIVATE

Chrome extension that reads a job description from the active tab, calls the Claude API with structured tool-use output, and generates a tailored, ATS-optimized resume PDF client-side — including keyword gap analysis against a master profile.

JavaScriptClaude APIChrome ExtensionsjsPDF

more on github

Earlier work in Java and Python, plus a full-stack database course project from ASU. The recent work — agents, tracing, generative systems — lives in the repos above.

BROWSE REPOS →
[04] EXPERIENCE.LOG

Where I've worked

Two-plus years building regulated, high-throughput financial systems — and changing how the team builds them.

Software Engineer · Wells Fargo

2024-07 → NOW
AUTO LENDING TECHNOLOGY · CHANDLER, AZ
  • Engineered C#/.NET and Java microservices automating statement generation for the nationwide auto loan portfolio — architected for 100K+ statements daily at peak, cutting defects ~20%.
  • Designed and maintained Apache Kafka event streaming pipelines powering real-time data flow across the majority of production applications.
  • Led AI adoption across the engineering team — delivered internal presentations on AI workflow integration and championed GitHub Copilot Agent Mode with MCP-connected tooling as the team standard, compressing feature delivery ~50%.
  • Migrated legacy batch jobs to Azure (Kubernetes/OpenShift), cutting end-to-end failures ~30%; built CI/CD with Harness and Azure DevOps for zero-downtime deploys across 4+ services.
  • Drove a 25% reduction in SQL Server execution times by overhauling critical queries and stored procedures in high-throughput batch workflows.

Software Engineering Intern · Wells Fargo

SUMMERS 2022 + 2023
CHANDLER, AZ
  • Built a C#/.NET automation tool for loan rate sheet validation — cut validation cycle time from ~3 days to under 4 hours (~80% less manual review).
  • Delivered full-stack React features across internal banking portals on a microfrontend architecture; expanded CI-integrated Selenium regression coverage ~60%.
[05] CAPABILITIES

What I work with

Production experience first — the top rows ship at Wells Fargo or in the open-source work above.

LANGUAGES

C#JavaPythonTypeScriptJavaScriptSQLC++

BACKEND + STREAMING

.NET / ASP.NET CoreSpring BootApache KafkaMicroservicesREST APIs

CLOUD + DEVOPS

Azure (AZ-900)KubernetesOpenShiftDockerHarnessAzure DevOpsCI/CD

AI + AGENTS

Model Context ProtocolClaude APIGitHub Copilot Agent ModeMulti-agent orchestrationAI workflow design

DATA

SQL ServerPostgreSQLMySQLMongoDBSQLite

FRONTEND + TESTING

ReactMicrofrontendsChrome extensionsSeleniumSpecFlow (BDD)
[06] TRAINING_DATA

Education & certifications

M.S. Computer Science

Arizona State University · May 2024
GPA 4.0 / 4.0

B.S. Computer Science

Arizona State University · May 2023
GPA 4.0 / 4.0
Microsoft Azure Fundamentals (AZ-900)
Oracle Certified Associate, Java SE 8
[07] OPEN_CHANNEL

Let's build something

Backend, platform, and AI-agent engineering roles. U.S. citizen, open to remote and relocation.