Tisha Talks Tech
On YouTube I break down how agentic systems work, walk through real engineering problems, and share what I've picked up building at Microsoft.
Tisha Talks Tech
AI agents, engineering deep dives, and career notes.
Software engineer at Microsoft. I work on making AI agents reliable in the real world, the part that decides whether they hold up outside a demo.
I build data platform infrastructure at Microsoft, where my work sits where large-scale analytics meets agentic AI. Most of what I actually do is make agents boringly reliable: durable state so they don't forget, deterministic execution so a failure can be reproduced, and self-healing workflows that recover without someone getting paged at 2am.
I treat AI as something to architect, not just consume. The interesting problems usually aren't in the model, they're in the orchestration around it: how coding agents, reliability agents, and spec-driven workflows actually hold together once real traffic hits them, rather than in a tidy demo.
Requirements are no longer static documents. They are the first architectural control surface, where systems inherit intent before implementation begins.
From my LinkedIn series on the agentic SDLCOn the research side, I publish peer-reviewed applied-ML work with 150+ citations. And I do most of this in the open, through my blog, talks, and a running LinkedIn series.
Reliability isn't one feature you bolt on at the end. It's something you engineer at every stage, from the moment a requirement is written to the moment an agent quietly recovers from an incident on its own.
Spec-driven dev
SWE agents
Testing agents
SRE agents
Cost & reliability
Requirements as the first control surface. I work with Spec Kit across greenfield and brownfield so intent flows cleanly into what gets built.
The Azure DevOps SWE Agent and custom agents: architecture, MCP integration, and automating pull request creation and implementation.
Playwright Planner, Generator, and Healer agents that write and self-heal test cases automatically, in VS Code and Azure Foundry.
The Azure SRE Agent: incident automation, ICM and DevOps integration, and sub-agent builder workflows that keep things dependable.
Making repos genuinely agent-ready through structure, docs, and context engineering, including Microsoft's first-party Agency platform.
FinOps and token optimization for non-deterministic agents, so the bill stays visible and under control as systems scale.
I share what I'm building with engineering audiences inside and outside Microsoft.
A practical look at cost management and token optimization for non-deterministic agents: where the spend actually goes, how to make it visible, and how to design agents that stay economical as they scale.
Conference details →AI Engineer World's Fair 2026, online track
Microsoft APAC AI Forum
Sessions I presented in Microsoft's internal AI Driven Engineering (AIDE) series, covering agents across the development lifecycle.
Architecture, custom agents, MCP server integration, features, and prompting best practices.
Onboarding, incident automation, ICM and DevOps integration, and sub-agent builder workflows.
Brownfield migration with Spec Kit, automated PR creation, and Playwright Planner, Generator, and Healer agents.
Microsoft's first-party agent platform and patterns for making repositories truly AI-first.
Copilot SDK and CLI, MCP server integration, workflow handling, and compliance guidance with Liquid MCP.
These aren't slogans. They're the lessons that keep showing up in my work, and they shape how I build.
With agents, the model is the easy part. Whether it holds up under real traffic is what people actually feel and remember.
Non-determinism is the enemy of debugging. I design for reproducible runs so a prod failure is a lead, not a mystery.
Durable state and self-healing workflows are unglamorous, but they're what separate a demo from a system you can trust.
The best systems come from both: rigour from research, pragmatism from shipping. I try to live in that overlap.
The fastest way I've found to get good at something this new is to work on hard problems and then actually show the work, what shipped, what broke, and the messy reasoning in between. So I write the long post, give the talk, and publish the thing that isn't perfect yet.
My blog goes deep on the hard parts of agent engineering: memory, reproducibility, and structure. A few recent ones:
On YouTube I break down how agentic systems work, walk through real engineering problems, and share what I've picked up building at Microsoft.
AI agents, engineering deep dives, and career notes.
Speaking invitations, collaborations, or just to say hi.
An open-source effort focused on the infrastructure that makes AI agents reliable in the real world.
Open infrastructure for running AI agents reliably, from durable state to reproducible execution. A work in progress, built in the open.
View on GitHub →