AI is leverage, not magic.
The quality of agent work reflects the people, context, tools, and feedback around it.
Staff Engineer at Netflix
Building the engineering systems for an agentic software organization.
I lead technical strategy and build production platforms that enable large engineering organizations to move safely from AI-assisted development toward autonomous software engineering.
At Netflix, my work spans autonomous code change, deterministic validation and remediation, agent runtime infrastructure, observability, model access, policy and governance, and developer productivity. I was a founding member of the platform modernization team and have helped build systems that have shipped thousands of validated agent-driven pull requests.
Enterprise scale
Founding member, Netflix Platform Modernization
Production autonomy
Thousands of validated agent-driven changes shipped
Technical strategy
From authority boundaries to validation and measurement
Organizational leverage
Platform capabilities that compound across engineering
Technical thesis
Build the system around the model.
Agentic software development is an engineering discipline: agents create leverage, but the surrounding architecture determines whether that leverage produces dependable outcomes.
Autonomy follows verifiability.
Increase authority when work is observable, testable, attributable, constrained, and reversible.
Own the control plane.
Keep enterprise context, policy, execution, and evidence under architectural control while models remain replaceable.
Raise the quality ceiling.
Cheaper implementation should buy better testing, modernization, and software—not just lower cost.
Leadership & impact
Technical authority is visible in the systems that other teams can use.
The common thread is not a particular model or framework. It is designing an engineering system in which higher autonomy produces more validated outcomes, better operational evidence, and durable leverage for the organization.
01
Autonomous software evolution
Production agent systems that take repetitive engineering work through governed execution, deterministic validation, remediation, and reviewable code change.
02
Enterprise agent platform
The shared operating substrate for agents: secure runtime, identity, tool governance, model access, telemetry, evaluation, cost attribution, and targeted controls.
03
Modernization that compounds
Platform abstractions and automation that turn difficult change into reusable organizational capability rather than a sequence of team-by-team projects.
Research & Writing
Technical thinking for autonomous engineering
Writing on operating autonomous agents, agent architecture, evaluation, governance, developer productivity, and the future of software engineering.
Agent Architecture
Engineering Principles for the Agentic Era
A practical case for optimism, rigor, and ownership in AI-assisted software development: build the system around the model.
Agent Architecture
The Agent Control Plane
Autonomous AI agents are becoming a new production substrate. The hard enterprise problem is not just building smarter agents; it is operating them with identity, observability, policy enforcement, cost attribution, runtime isolation, evals, and kill switches.
Agent Architecture
Agent Observability Belongs at the Gateway
Client-side logs are not enough for enterprise AI agents. The model gateway is the best choke point for observing model calls, tool intent, cost, risk, and agent behavior.
Get in touch
Open to conversations about agentic software engineering, technical architecture, enterprise platform strategy, autonomous systems, and engineering productivity.