Set a Default Response Mode for Your Declarative Agent

A customer built a declarative agent for quick SKU lookups, but Copilot kept spinning up deeper reasoning passes for what should have been two-second answers. “Why is my lookup agent thinking so hard about a price check?” Now there’s a clean answer.

What Is Default Response Mode?

M365 Copilot gives users three response modes that control how the model approaches each turn:

Auto: The model picks the right mode per turn based on the user’s prompt. This is the default for every declarative agent, and it covers the vast majority of scenarios beautifully.
Quick response: Optimized for speed. Short, direct answers with minimal deliberation.
Think deeper: Optimized for depth. Extended reasoning, multi-step analysis, and thorough exploration.

Until now, every declarative agent started in Auto mode. Users could manually switch modes mid-conversation, but there was no way for the agent builder to set the starting point. The new default_response_mode property changes that. You declare which mode your agent opens in, and the experience feels right from the very first turn.

📝 Note

The property is prefixed with default_ for a reason: users can always override it through the model selector mid-conversation. When they do, Copilot now shows them a UX warning so they know they’re stepping outside what the agent author intended. This property sets the starting point, not a lock.

Why This Matters

Think about it from the user’s perspective. If your agent is purpose-built for quick lookups (inventory checks, status queries, simple Q&A), starting in Auto mode means the model sometimes overthinks a straightforward question. The answer is correct, but the latency feels wrong for a tool that should feel snappy.

On the flip side, if your agent is built for deep research, strategic planning, or complex analysis, you want the model to bring its full reasoning capabilities from the start. Starting in Think deeper mode sets that expectation immediately.

Matching the default response mode to your agent’s purpose removes friction. The agent feels like it was designed for exactly what the user needs because, well, it was.

The Configuration

📝 Note

default_response_mode ships with manifest schema v1.7, alongside the new editorial_answers property and the depends_on option for conversation starters. Bump your $schema URL and version to v1.7 to use it.

Add default_response_mode inside the behavior_overrides block of your declarativeAgent.json:

{
  "$schema": "https://developer.microsoft.com/json-schemas/copilot/declarative-agent/v1.7/schema.json", 
  "version": "v1.7", 
  "name": "SKU Lookup Agent",
  "description": "Quick lookups for product SKUs, pricing, and inventory.",
  "instructions": "$[file('instructions.txt')]",
  "behavior_overrides": {
    "default_response_mode": "Quick response"
  }
}

Three allowed values:

Value	Best For	Why
`"Auto"`	General-purpose agents	The model picks the optimal mode per turn. Great default for agents that handle a mix of quick questions and deeper analysis.
`"Quick response"`	Lookup tools, Q&A bots, high-volume utility agents	Snappy answers with minimal deliberation. Perfect when speed is the priority.
`"Think deeper"`	Research agents, planning tools, reasoning-heavy workflows	Extended reasoning from the first turn. Ideal when depth and thoroughness matter most.

💡 Tip

If you’re unsure which mode to pick, stick with "Auto". It’s the smart default for a reason: the model is genuinely good at routing prompts to the right depth. Only pin a specific mode when your agent has a clear, singular purpose.

Combining with Other Behavior Overrides

default_response_mode lives alongside the existing behavior overrides you might already be using. Here is a full example that combines all three:

{
  "$schema": "https://developer.microsoft.com/json-schemas/copilot/declarative-agent/v1.7/schema.json",
  "version": "v1.7",
  "name": "Legal Research Assistant",
  "description": "Deep analysis of contracts, clauses, and regulatory documents.",
  "instructions": "$[file('instructions.txt')]",
  "behavior_overrides": {
    "default_response_mode": "Think deeper", 
    "suggestions": {
      "disabled": false
    },
    "special_instructions": {
      "discourage_model_knowledge": true
    }
  }
}

This legal research agent starts in Think deeper mode (because contract analysis demands thoroughness), keeps suggestions enabled (so lawyers discover follow-up questions naturally), and discourages model knowledge (because legal answers must come from the grounded documents, not training data). Each override serves a specific purpose, and they compose cleanly together.

ℹ️ Info

If you haven’t explored behavior overrides yet, check out Behavior Overrides in Declarative Agents for the full rundown on discourage_model_knowledge and suggestions.

A Quick Decision Framework

Not sure which response mode fits your agent? Ask yourself one question: What does a typical interaction look like?

“Give me the status of ticket #4521” → Quick response. The user wants a fast, factual answer.
“Analyze the risk profile across our Q3 vendor contracts” → Think deeper. The user needs the model to reason through multiple documents.
“Help me with whatever comes up today” → Auto. The agent handles a mix of tasks, and the model should adapt per turn.

Match the mode to the primary use case, not the edge case. If 80% of your agent’s interactions are quick lookups with the occasional deep dive, Quick response is still the right default because users can switch to Think deeper when they need it.

The Value You Just Unlocked

With one line of JSON, your declarative agent now communicates its purpose from the first interaction:

Reduced latency for lookup agents: No more waiting for the model to deliberate on a straightforward question
Deeper reasoning from turn one: Research and analysis agents bring their full capabilities immediately
Better user expectations: The response mode signals what kind of agent this is before the first answer arrives
Zero code required: It’s a single string property in your manifest

A small configuration change, but the kind that makes your agent feel intentional rather than generic.

Resources

Go set a default response mode and let your agent be itself from turn one. More at The Manifest.