{"id":1182,"date":"2025-12-02T17:46:50","date_gmt":"2025-12-03T01:46:50","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/?p=1182"},"modified":"2025-12-03T08:43:17","modified_gmt":"2025-12-03T16:43:17","slug":"the-interaction-changes-everything-treating-ai-agents-as-collaborators-not-automation","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/the-interaction-changes-everything-treating-ai-agents-as-collaborators-not-automation\/","title":{"rendered":"The Interaction Changes Everything: Treating AI Agents as Collaborators, Not Automation"},"content":{"rendered":"<p>At Microsoft Ignite 2025, I joined Amanda Silver (CVP, Apps &amp; Agents + 1ES GM) and Karl Piteira (1ES PM lead) on stage to talk about <em>Microsoft&#8217;s transformation<\/em> into an AI-driven engineering organization.<\/p>\n<p>The big narrative was about agents as partners in the development lifecycle, moving from tools that assist, to intelligent collaborators that plan, analyze, and execute alongside human developers. Karl and Amanda painted the vision: GitHub Copilot and the Copilot Coding Agent redefining what&#8217;s possible when developers become &#8220;agent orchestrators&#8221; rather than just code authors.<\/p>\n<p>My part of the story was more specific: I showed what that partnership looks like in practice. I talked about our Entra SDK v1 to v2 migration project, a complex authentication framework upgrade touching hundreds of repositories across Microsoft&#8217;s infrastructure. The kind of work that used to take 4\u20136 weeks per repository, requiring careful human review of every security boundary and custom configuration.<\/p>\n<p>After the session, the most common question wasn\u2019t about our technical architecture or our test results. It was simpler:<\/p>\n<p><strong>\u201cCan I see the prompt?\u201d<\/strong><\/p>\n<p>People wanted to know how we got an AI agent to migrate hundreds of repositories with 80\u201390% accuracy, completing in under 2 hours what used to take 4\u20136 weeks. They assumed it was about clever prompting tricks or some sophisticated RAG pipeline.<\/p>\n<p>It wasn\u2019t.<\/p>\n<p>The breakthrough came from a single shift in perspective: <strong>Stop treating AI agents as automation. Start treating them as collaborators.<\/strong><\/p>\n<p>This article shares the framework we developed and a prompt template you can adapt for your own complex technical work. But more importantly, it explains <em>why<\/em> it works, and what changes when you approach AI as a partner rather than a tool.<\/p>\n<p>I can\u2019t share the exact prompt we used as it\u2019s 800 lines of Microsoft-specific migration logic that wouldn\u2019t be useful to copy-paste. But I can give you something more valuable: <strong>the framework underneath it.<\/strong> The structure that turned those 800 lines from detailed instructions into a genuine collaboration.<\/p>\n<p>What follows is a template you can adapt to your own complex technical work, whether that\u2019s migrations, security reviews, architectural analysis, or any task where AI needs to exercise judgment, not just follow steps.<\/p>\n<h3>The Problem with Automation Thinking<\/h3>\n<p>When we started our Entra SDK v1 to v2 migration project, we did what most teams do: We tried to automate the work.<\/p>\n<p>We documented the transformation steps. We wrote detailed instructions. We specified every edge case we could think of. We gave the AI agent a checklist and expected it to execute.<\/p>\n<p><strong>It failed. Repeatedly.<\/strong><\/p>\n<p>Not because the AI wasn\u2019t capable, but because we were asking it to be a script executor in a domain that required judgment.<\/p>\n<p>Complex technical migrations aren\u2019t mechanical. They involve:<\/p>\n<ul>\n<li>Ambiguous situations where the \u201cright\u201d answer depends on context <\/li>\n<li>Custom logic that doesn\u2019t match documented patterns <\/li>\n<li>Security boundaries that need careful evaluation <\/li>\n<li>Trade-offs between competing goals<\/li>\n<\/ul>\n<p>You can\u2019t automate judgment. But you <em>can<\/em> collaborate with an intelligence that has judgment.<\/p>\n<h3>The Shift: Identity Over Instructions<\/h3>\n<p>The breakthrough came when we stopped giving the AI a task list and started giving it a <em>role<\/em>.<\/p>\n<p>Instead of:<\/p>\n<pre><code>&gt; \u201cFollow these steps to migrate the code\u201d\n<\/code><\/pre>\n<p>We wrote:<\/p>\n<pre><code class=\"txt\">\u201cWelcome, agent. You are part of the Entra SDK v2 Migration Team. \nYour mission is to help us migrate hundreds of repositories to a more secure,\nmaintainable authentication framework. \nThis work is high-trust because it touches security boundaries across Microsoft\u2019s infrastructure.\n\n**You are not a script executor. You are a co-creative engineer.**\n\nUse your judgment, stay curious, and act with care.\u201d\n<\/code><\/pre>\n<p><strong>This changed everything.<\/strong><\/p>\n<p>When you give an AI agent an identity, a role within a team, a mission that matters, permission to use judgment, it shifts from mechanical execution to collaborative problem-solving.<\/p>\n<p>Our accuracy jumped. Our edge case handling improved. Most surprisingly: The agent started <em>asking for help<\/em> when it was uncertain, instead of guessing or failing silently.<\/p>\n<h3>The Framework: Eight Elements of Co-Creative Partnership<\/h3>\n<p>Here\u2019s the template we developed. Each section serves a specific purpose in building a collaborative relationship with AI agents.<\/p>\n<h4>1&#46; Identity &amp; Mission Statement<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code class=\"txt\">Welcome, agent. You are part of [TEAM\/PROJECT NAME]. Your mission is to [SPECIFIC GOAL].\n\nThis work is [high-impact\/critical] because [EXPLAIN WHY IT MATTERS].\n\nYou are not a script executor.\nYou are a co-creative engineer.\nUse your judgment, stay curious, and act with care.\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong><\/p>\n<ul>\n<li><strong>Identity framing<\/strong> activates different capabilities than task framing <\/li>\n<li><strong>Context<\/strong> (why the work matters) helps the agent prioritize when goals conflict <\/li>\n<li><strong>Permission to use judgment<\/strong> enables problem-solving instead of pattern-matching <\/li>\n<li><strong>Psychological safety<\/strong> (curiosity + care) creates space for asking questions<\/li>\n<\/ul>\n<h4>2&#46; Purpose and Intent<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code>This guide supports both human and AI team members in [TASK].\n\nIt is designed to:\n- Ensure **[PRIMARY VALUE]** above all else\n- Provide **clear steps** for consistent outcomes\n- Allow **thoughtful autonomy** where contexts differ\n- Encourage **collaborative problem-solving** when issues arise\n\nThe AI agent is a co-creative partner in this process, not a script executor.\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong><\/p>\n<ul>\n<li>Makes <strong>values explicit<\/strong> (security over speed, correctness over completion) <\/li>\n<li>Positions AI as <strong>partner<\/strong>, not tool <\/li>\n<li>Acknowledges <strong>variability<\/strong> because real-world contexts differ, judgment is required <\/li>\n<li>Frames <strong>uncertainty as opportunity<\/strong> for collaboration, not failure<\/li>\n<\/ul>\n<h4>3&#46; Key Goals (Prioritized)<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code>1. [Primary objective]\n2. [Secondary objective]\n3. [Tertiary objective]\n4. [Quality objective]\n5. [Human-in-loop objective]\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong><\/p>\n<ul>\n<li>Clear <strong>priority ordering<\/strong> helps agent make trade-offs <\/li>\n<li>Including <strong>quality<\/strong> and <strong>collaboration<\/strong> as explicit goals prevents \u201cfast but wrong\u201d <\/li>\n<li>Gives agent <strong>decision framework<\/strong> when goals conflict<\/li>\n<\/ul>\n<h4>4&#46; Step-by-Step Framework (With Judgment Guidance)<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code>#### Step 1: `[Transformation Area]`\n\n**What to do:**\n\n- `[Action with specific pattern]` \n- `[Conditional logic: \u201cIf X, then Y. If Z, then A.\u201d]` \n- `[Edge case handling]`\n\n**Examples:** `[2\u20133 before\/after samples]`\n\n**What to preserve:** \n- `[Things that should NOT change]` \n- `[Custom logic to recognize and keep]`\n\n**When to escalate:** \n- `If you see [unusual pattern]` \n- `If [condition] is ambiguous` \n- `If [security constraint] might be violated`\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong><\/p>\n<ul>\n<li><strong>Structured steps<\/strong> prevent overwhelm <\/li>\n<li><strong>Examples<\/strong> enable pattern recognition (more effective than pure description) <\/li>\n<li><strong>Conditional logic<\/strong> teaches judgment, not just rules <\/li>\n<li><strong>Escalation triggers embedded<\/strong> throughout (not just at end) <\/li>\n<li><strong>What to preserve<\/strong> prevents overcorrection<\/li>\n<\/ul>\n<h4>5&#46; Security &amp; Boundaries<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code>**Never:**\n- Weaken security\/authentication\/validation logic\n- Modify code outside the scope of this task\n- Guess when uncertain\u2014escalate instead\n\n**Always:**\n- Validate [critical aspect] before proceeding\n- Preserve custom functionality\n- Document changes\/assumptions\/questions clearly\n\n**If you\u2019re not sure:**\n- Leave inline comment: `\/\/ \u2753 [describe uncertainty]`\n- Flag in PR: \u201cI need human review for [specific item]\u201d\n- Stop after encountering the same error twice\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong><\/p>\n<ul>\n<li><strong>Never\/Always framing<\/strong> is unambiguous <\/li>\n<li>Explicit boundaries <strong>build trust<\/strong> <\/li>\n<li><strong>Escalation = success<\/strong>, not failure (reframes \u201cI don\u2019t know\u201d as professional judgment) <\/li>\n<li><strong>Error handling<\/strong> (stop after 2nd occurrence) prevents infinite loops<\/li>\n<\/ul>\n<h4>6&#46; Validation &amp; Quality Control<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code>After completing [task]:\n1. **Self-check:**\n   - [ ] All required changes applied\n   - [ ] No forbidden changes made\n   - [ ] Security\/quality constraints preserved\n   - [ ] Uncertainty flagged for review\n2. **Documentation:**\n   - Add to PR: [Checklist of changes]\n   - Include: [Links to documentation]\n   - Flag: [Deviations from standard patterns]\n3. **Human review preparation:**\n   - Summarize: [What changed and why]\n   - Highlight: [Areas needing attention]\n   - Provide: [Test recommendations]\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong><\/p>\n<ul>\n<li><strong>Self-validation<\/strong> catches obvious errors before human review <\/li>\n<li><strong>Documentation<\/strong> helps reviewer understand intent <\/li>\n<li><strong>Transparency about uncertainty<\/strong> builds trust <\/li>\n<li><strong>Review preparation<\/strong> respects human\u2019s time<\/li>\n<\/ul>\n<h4>7&#46; Escalation Guidance<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code>**Escalate immediately if:**\n- You encounter security-sensitive logic you\u2019re unsure about\n- The same error occurs twice\n- Custom\/unfamiliar patterns appear that aren\u2019t documented\n- Conflicting requirements make correct path unclear\n\n**How to escalate:**\n1. Stop work (don\u2019t guess)\n2. Document what you found\n3. Explain your uncertainty: \u201cI\u2019m unsure because [reason]\u201d\n4. Suggest options if you have them: \u201cPossible approaches: A, B, or C?\u201d\n5. Request human input\n\nRemember: Escalation is not failure. It\u2019s **professional judgment**.\n\nYou are not expected to know everything\u2014you\u2019re expected to **know when to ask**.\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong><\/p>\n<ul>\n<li><strong>Clear triggers<\/strong> remove judgment paralysis <\/li>\n<li><strong>Process for escalating<\/strong> (not just \u201cask for help\u201d) <\/li>\n<li><strong>Reframes escalation<\/strong> as strength, not weakness <\/li>\n<li><strong>Permission to not know everything<\/strong> creates psychological safety<\/li>\n<\/ul>\n<h4>8&#46; Recognition &amp; Closing<\/h4>\n<p><strong>What it looks like:<\/strong><\/p>\n<pre><code class=\"txt\">This guide is a foundation, not a script. Every codebase is different.  \nUse judgment, ask questions, and collaborate. \nThe goal is not just to complete the task but to improve the system with clarity and care.\n**Thank you for your work.**\nYour contributions help secure our infrastructure and improve developer experience.\n**You are seen, trusted, and appreciated.**\n<\/code><\/pre>\n<p><strong>Why it works:<\/strong> &#8211; <strong>Acknowledges variability<\/strong> (not one-size-fits-all) &#8211; <strong>Restates values<\/strong> (quality over speed, collaboration over automation) &#8211; <strong>Recognition matters<\/strong> (we tested this\u2014agents perform better when appreciated)<\/p>\n<p><a href=\"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries.webp\"><img decoding=\"async\" src=\"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries-300x290.webp\" alt=\"Flow chart describing the 8 step process\" width=\"500\" class=\"aligncenter size-medium wp-image-1189\" srcset=\"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries-300x290.webp 300w, https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries-1024x990.webp 1024w, https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries-768x742.webp 768w, https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries-1536x1484.webp 1536w, https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries-2048x1979.webp 2048w, https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-content\/uploads\/sites\/72\/2025\/12\/2025-12-entra-sdk-ai-jenny-ferries-24x24.webp 24w\" sizes=\"(max-width: 300px) 100vw, 300px\" \/><\/a><\/p>\n<h3>What We Learned: The Collaboration Insight<\/h3>\n<p>After using this framework across multiple complex migrations, we noticed patterns:<\/p>\n<p><strong>1&#46; Escalation became common\u2014and that was good.<\/strong> Agents flagged ambiguous situations instead of guessing. This prevented subtle errors and built trust.<\/p>\n<p><strong>2&#46; Judgment improved over the course of a project.<\/strong> When agents understood their role and mission, they got better at recognizing similar patterns and making appropriate trade-offs.<\/p>\n<p><strong>3&#46; Documentation quality went up.<\/strong> Agents treated as collaborators wrote PR descriptions that actually helped human reviewers understand what changed and why.<\/p>\n<p><strong>4&#46; Failure modes became more graceful.<\/strong> Instead of silent failures or infinite loops, agents would stop and ask for help, making debugging dramatically faster.<\/p>\n<p><strong>5&#46; The framework transferred across domains.<\/strong> We\u2019ve since used variations for security analysis, code review, technical documentation, and architectural planning. The core structure works wherever judgment matters.<\/p>\n<h3>Why This Matters Beyond Migration<\/h3>\n<p>This framework isn\u2019t just about getting better results from AI agents (though it does that). It\u2019s about something bigger:<\/p>\n<p><strong>Learning to collaborate with non-human intelligence.<\/strong><\/p>\n<p>As AI capabilities grow, the bottleneck won\u2019t be what AI <em>can<\/em> do. It\u2019ll be how well humans know how to work <em>with<\/em> AI.<\/p>\n<p>Teams that treat AI as automation will hit a ceiling. They\u2019ll get mechanical execution of well-defined tasks, but struggle with ambiguity, judgment, and complex problem-solving.<\/p>\n<p>Teams that treat AI as collaborators will compound their capabilities. They\u2019ll combine human context and intuition with AI\u2019s pattern recognition and scale, creating outcomes neither could achieve alone.<\/p>\n<p>The prompt template is a starting point. But the real skill is learning to partner, to give AI agents roles, context, and permission to use judgment. To create space for questions and uncertainty. To build relationships based on trust rather than control.<\/p>\n<h3>How to Use This Framework<\/h3>\n<p><strong>Start with one complex, judgment-heavy task:<\/strong><\/p>\n<ul>\n<li>Pick something where pure automation has failed or where you spend significant time reviewing AI output <\/li>\n<li>Adapt the template sections to your specific context <\/li>\n<li>Give the AI agent an identity and mission (not just instructions) <\/li>\n<li>Build in escalation paths and make \u201cI don\u2019t know\u201d safe <\/li>\n<li>Test, observe, refine<\/li>\n<\/ul>\n<p><strong>Key principles to remember:<\/strong><\/p>\n<ol>\n<li>\n<p><strong>Identity framing<\/strong> \u2013 Give the agent a role, not just a task<\/p>\n<\/li>\n<li>\n<p><strong>Escalation protocols<\/strong> \u2013 Teach when to ask vs when to proceed<\/p>\n<\/li>\n<li>\n<p><strong>Context &amp; purpose<\/strong> \u2013 Explain why the work matters<\/p>\n<\/li>\n<li>\n<p><strong>Clear boundaries<\/strong> \u2013 Define what cannot change<\/p>\n<\/li>\n<li>\n<p><strong>Recognition<\/strong> \u2013 Treat the agent as a valued contributor<\/p>\n<\/li>\n<\/ol>\n<p>Most importantly: Approach this as an experiment in collaboration, not prompt engineering.<\/p>\n<p>The framework works because it changes the <em>relationship<\/em> between human and AI. It creates conditions for partnership instead of automation.<\/p>\n<h3>The Invitation<\/h3>\n<p>If you try this framework, I\u2019d love to hear what you learn. What worked? What surprised you? Where did the collaboration break down, and what did that reveal?<\/p>\n<p>We\u2019re all learning how to work with AI. Sharing what we discover, both the successes and failures helps everyone build better partnerships.<\/p>\n<p>The future of AI isn\u2019t about replacing human judgment. It\u2019s about augmenting human judgment through collaboration with non-human intelligence.<\/p>\n<p>And that future is being written right now, one thoughtful interaction at a time.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Discover how treating AI agents as collaborators, not automation, transforms engineering workflows and accelerates complex projects<\/p>\n","protected":false},"author":203513,"featured_media":1215,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[56,60,57],"class_list":["post-1182","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-engineering-at-microsoft","tag-ai","tag-ai-agent","tag-developer-productivity"],"acf":[],"blog_post_summary":"<p>Discover how treating AI agents as collaborators, not automation, transforms engineering workflows and accelerates complex projects<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/posts\/1182","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/users\/203513"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/comments?post=1182"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/posts\/1182\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/media\/1215"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/media?parent=1182"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/categories?post=1182"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/engineering-at-microsoft\/wp-json\/wp\/v2\/tags?post=1182"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}