apa.yaml

################################################################################
# Microsoft Agent Platform Advisor — Scoring Matrix
# Platforms: Agent Builder (agent_builder), Microsoft 365 Copilot (m365_copilot),
#            Copilot Studio (copilot_studio), Microsoft Foundry (foundry)
#
# Score scale: 0 = not a fit · 1 = weak signal · 2 = moderate · 3 = strong
# Max raw score per platform: 15 (5 questions × max 3)
################################################################################

meta:
  version: "1.4"
  # Shown in UI footer / results stewardship strip
  guidance_verified: "2026-08"
  # ISO date shown as "Last updated" in the footer. Bump when content changes.
  last_updated: "2026-08-19"
  platforms:
    - id: agent_builder
      label: Agent Builder
    - id: m365_copilot
      label: Microsoft 365 Copilot
    - id: copilot_studio
      label: Copilot Studio
    - id: foundry
      label: Microsoft Foundry

################################################################################
# QUESTIONS
################################################################################

questions:

  - id: q1
    label: Who is building this agent?
    purpose: Sets persona weight for interpreting later answers
    prompt: Some platforms are designed for makers using low-code tools, while others require professional development skills.
    options:
      - id: q1a
        label: Business user or subject matter expert — no coding experience
        scores:
          agent_builder: 3
          copilot_studio: 2
          foundry: 0

      - id: q1b
        label: Low-code maker or IT professional — comfortable with drag-and-drop tools and configuration
        scores:
          agent_builder: 1
          copilot_studio: 3
          foundry: 0

      - id: q1c
        label: Professional developer — writes code and builds software
        scores:
          agent_builder: 0
          copilot_studio: 2
          foundry: 3

      - id: q1d
        label: Data scientist or AI/ML engineer — works with AI models and data infrastructure
        scores:
          agent_builder: 0
          copilot_studio: 2
          foundry: 3

  - id: q8
    label: Who will use this agent?
    purpose: External-facing is a hard constraint that affects platform eligibility
    prompt: Will this agent be used by a small internal group, a broad internal audience, or external users such as customers or partners?
    hard_rules:
      - condition: option in [q8b]
        effect: >
          Set agent_builder = 0 and m365_copilot = 0.
          Agent Builder has no external publishing path.
          Microsoft 365 Copilot is tenant-scoped only.
    options:
      - id: q8a
        label: Me or a small internal team — quick agent for a bounded group
        scores:
          agent_builder: 3
          copilot_studio: 2
          foundry: 1

      - id: q8c
        label: A department or broad internal audience — many employees need a managed agent
        scores:
          agent_builder: 1
          copilot_studio: 3
          foundry: 2

      - id: q8b
        label: External users — customers, partners, or the public
        scores:
          agent_builder: 0
          copilot_studio: 3
          foundry: 3
        hard_rule_trigger: true

      - id: q8d
        label: Not decided yet
        scores:
          agent_builder: 2
          copilot_studio: 2
          foundry: 1

  - id: q2
    label: Where will users interact with this agent?
    purpose: Deployment surface is often a hard constraint
    prompt: Think about where people will access or use the agent in their day-to-day work.
    options:
      - id: q2a
        label: Inside Microsoft 365 Copilot chat — stay on Copilot's orchestrator and models (Microsoft365.com, Office.com, or Teams)
        scores:
          agent_builder: 3
          copilot_studio: 3
          foundry: 2

      - id: q2b
        label: In a custom app you host — own endpoints, models, or runtime control (website, mobile, or backend service)
        scores:
          agent_builder: 0
          copilot_studio: 3
          foundry: 3

      - id: q2c
        label: Running automatically in the background — triggered by events, not by a person chatting with it
        scores:
          agent_builder: 0
          copilot_studio: 3
          foundry: 3

      - id: q2d
        label: Multiple places, or not decided yet
        scores:
          agent_builder: 1
          copilot_studio: 3
          foundry: 3

  - id: q4
    label: What should this agent do?
    purpose: Task complexity separates lightweight agents from enterprise platforms; runtime ownership is resolved conditionally
    prompt: What type of work do you want this agent to handle? Choose the option that best represents the most advanced task you expect it to perform.
    hard_rules:
      - condition: option == q4d
        effect: >
          Cap agent_builder and m365_copilot at 0 regardless of other answers.
          Copilot Studio and Foundry can both support complex orchestration.
    options:
      - id: q4a
        label: Answer questions in a single exchange — Q&A, lookups, or summaries
        scores:
          agent_builder: 3
          copilot_studio: 3
          foundry: 1

      - id: q4b
        label: Have a back-and-forth conversation and remember context
        scores:
          agent_builder: 2
          copilot_studio: 3
          foundry: 2

      - id: q4e
        label: Create or analyze content inside Copilot — documents, charts, images, or lightweight data analysis
        scores:
          agent_builder: 3
          copilot_studio: 3
          foundry: 2

      - id: q4c
        label: Complete multi-step tasks — follow a process, check multiple systems, or take actions like submitting forms or updating records
        scores:
          agent_builder: 0
          copilot_studio: 3
          foundry: 3

      - id: q4d
        label: Manage complex workflows — coordinate multiple agents or handle long-running processes
        scores:
          agent_builder: 0
          copilot_studio: 3
          foundry: 3
        hard_rule_trigger: true

  - id: q3
    label: What information does this agent need to access?
    purpose: Grounding requirements narrow the field fast
    prompt: Where does the information this agent needs currently live? Pick the option closest to where the information lives today.
    options:
      - id: q3a
        label: Microsoft 365 content — SharePoint, OneDrive, Teams, Outlook, or people data
        scores:
          agent_builder: 3
          copilot_studio: 2
          foundry: 1

      - id: q3b
        label: Business systems already available through Microsoft 365 Copilot connectors — like Jira, ServiceNow, GitHub, or Azure DevOps
        scores:
          agent_builder: 2
          copilot_studio: 3
          foundry: 2

      - id: q3c
        label: Dataverse, custom connectors, or direct business APIs your team can expose to the agent
        scores:
          agent_builder: 0
          copilot_studio: 3
          foundry: 2

      - id: q3d
        label: A mix — Microsoft 365 content plus connector-backed business systems
        scores:
          agent_builder: 2
          copilot_studio: 3
          foundry: 2

      - id: q3e
        label: Public websites or uploaded files — scoped web sources, PDFs, Office files, or other embedded content
        scores:
          agent_builder: 3
          copilot_studio: 2
          foundry: 1

      - id: q3f
        label: Custom RAG, Azure AI Search, private indexes, Foundry IQ knowledge bases, or large-scale retrieval managed by engineering
        scores:
          agent_builder: 0
          copilot_studio: 1
          foundry: 3

################################################################################
# CONDITIONAL RUNTIME DISTINCTION (non-scored)
################################################################################

runtime_tiebreaker:
  id: q9
  label: Who should operate the agent runtime?
  prompt: Copilot Studio and Microsoft Foundry both fit your functional requirements. Choose who should own the execution environment.
  threshold_points: 2
  compare: [copilot_studio, foundry]
  legacy_managed_option_ids: [q9b, q9c]
  options:
    - id: q9a
      label: Microsoft should manage the agent runtime, sandbox, tools, and Power Platform governance
      prefer: copilot_studio
      over: foundry

    - id: q9d
      label: Our engineering team should own the code runtime, framework, endpoints, networking, identity, memory, or retrieval
      zero: [agent_builder, copilot_studio]

################################################################################
# SCORING ENGINE
################################################################################

scoring:

  # Step 1 — Hard rules are evaluated before summing.
  # They cap or zero out platforms regardless of cumulative scores.
  # Hard rules represent real platform limitations, not preferences.
  hard_rule_evaluation: pre_sum
  hard_rules:
    q4d:
      zero: [agent_builder, m365_copilot]
      label: "Complex agent orchestration — Agent Builder and M365 Copilot are not suitable for multi-agent or long-running orchestration"
    q4c:
      zero: [agent_builder]
      label: "Multi-step action workflows — Agent Builder cannot submit forms, update records, or take actions across systems"
    q8b:
      zero: [agent_builder, m365_copilot]
      label: "External user audience — Agent Builder and M365 Copilot cannot publish externally"
    q2b:
      zero: [agent_builder]
      label: "Custom app deployment — Agent Builder can only run inside Microsoft 365"
    q2c:
      zero: [agent_builder]
      label: "Background execution — Agent Builder has no event-driven or autonomous capabilities"
    q3c:
      zero: [agent_builder]
      label: "Direct business system integration — Agent Builder cannot directly connect to Dataverse, custom connectors, or business APIs"
    q3f:
      zero: [agent_builder]
      label: "Custom retrieval architecture — Agent Builder cannot directly use custom RAG, Azure AI Search, private indexes, Foundry IQ, or engineering-managed retrieval systems"
    q9d:
      zero: [agent_builder, copilot_studio]
      label: "Developer-owned runtime — Agent Builder and Copilot Studio do not provide an engineering-owned code runtime, framework, endpoint, network, identity, memory, or retrieval architecture"
  # Step 2 — Sum raw scores across all answered questions.
  raw_score_max: 15  # 5 questions × max score of 3

  # Step 2.5 — Persona preferences: soft overrides that force one platform
  # above another when a specific persona is selected. Unlike hard rules,
  # scores are preserved. A rationale message is shown to explain the override.
  # Kept for q1d: rare path but correct when DS/ML picks AB-leaning answers without
  # Foundry-only signals — prefer CS over AB for evaluations/model selection.
  persona_preferences:
    - when:
        q1: q1d
      prefer: copilot_studio
      over: agent_builder
      rationale: >
        Copilot Studio is recommended over Agent Builder for data scientists and AI/ML engineers
        because it supports curated model selection, agent evaluations, Foundry IQ integration,
        managed reasoning, portable skills, and more flexible orchestration — capabilities
        that Agent Builder does not offer. Use Foundry when the scenario requires a custom
        model or developer-owned runtime.
    - when:
        q9: q9a
      prefer: copilot_studio
      over: foundry
      rationale: >
        Copilot Studio is recommended because you want Microsoft to manage the reasoning
        harness, sandbox, tools, and Power Platform governance. Choose Foundry when your
        engineering team needs to own the runtime and infrastructure.

  # Step 3 — Map raw scores to recommendation strength.
  recommendation_thresholds:
    - min: 12
      max: 15
      label: Strong fit
      description: This platform is well-aligned with your requirements across all dimensions.
    - min: 8
      max: 11
      label: Good fit
      description: This platform meets most of your requirements with minor tradeoffs.
    - min: 4
      max: 7
      label: Partial fit
      description: This platform can address your scenario but may require workarounds.
    - min: 0
      max: 3
      label: Not recommended
      description: This platform is unlikely to meet your requirements in this scenario.

  # Step 5 — Tie handling: surface both as a complementary pair.
  tie_handling:
    threshold_points: 2
    present_as: complementary_pair
    # Persona-based tiebreakers — applied before valid_pairs when a specific
    # answer makes one platform a better fit despite equal scores.
    tiebreakers:
      - when:
          q1: q1c
        platforms: [agent_builder, copilot_studio]
        prefer: copilot_studio
        rationale: >
          When the builder is a professional developer and scores are equal,
          Copilot Studio is the better fit — it supports code-first authoring
          via the VS Code extension while Agent Builder is no-code only.
      - when:
          q1: q1d
        platforms: [copilot_studio, foundry]
        prefer: copilot_studio
        rationale: >
          When the builder is a data scientist or AI/ML engineer and scores are equal,
          Copilot Studio is preferred for time-to-value. Foundry still wins when the
          conditional runtime distinction requires engineering ownership.
    # Scored-path pairs only. m365_copilot is always zeroed in the full wizard, so
    # pairs that include it never fire on the scored path and are omitted here.
    valid_pairs:
      - platforms: [copilot_studio, foundry]
        rationale: >
          Choose Copilot Studio when Microsoft should manage the reasoning harness, sandbox,
          tools, and Power Platform governance. Choose Foundry when your team must own the
          code runtime, framework, endpoint, network, identity, memory, or retrieval architecture.
        why_not: >
          Prefer <strong>{winner}</strong> when its strengths match your answers;
          keep <strong>{runner}</strong> for the complementary lane rather than forcing one platform to do both.
      - platforms: [agent_builder, copilot_studio]
        rationale: >
          Agent Builder for quick no-code Microsoft 365 knowledge helpers; Copilot Studio
          when you need actions, governance, broader audience, or multi-channel publish.
        why_not: >
          <strong>{winner}</strong> fits the current scope better than <strong>{runner}</strong>;
          graduate from Builder to Studio when actions, ALM, or department-wide governance appear.

  # Cross-question contradiction notes — shown as contextual banners
  # when the user's answer combination is logically contradictory.
  cross_question_notes:
    - when:
        q2: q2c
        q4: q4a
      note: >
        You selected a background, event-driven agent but also chose simple Q&A.
        Background agents typically process events automatically rather than answering
        user questions. Consider whether your agent is event-driven or conversational.
    - when:
        q8: q8b
        q2: q2a
      note: >
        You selected external users but want the agent inside Microsoft 365 apps.
        External users typically can't access your organization's Teams, SharePoint,
        or Outlook. Your agent may need a custom web deployment to reach them.
    - when:
        q1: q1a
        q4: q4d
      note: >
        Multi-agent business orchestration in Copilot Studio is low-code, but designing
        child agents, A2A connections, and long-running processes still benefits from
        maker or IT partnership. For code-first multi-agent systems, partner with
        professional developers on Foundry.
    - when:
        q1: q1a
        q3: q3c
      note: >
        Direct business system integrations like Dataverse, custom connectors, or APIs
        usually require technical expertise to configure. Consider whether your IT or
        development team will help set up data access for the agent.
    - when:
        q1: q1a
        q3: q3f
      note: >
        Custom retrieval architectures like Azure AI Search, private indexes, Foundry IQ,
        or large-scale RAG usually require engineering expertise. Consider partnering with
        your development or data platform team before building the agent.
    - when:
        q1: q1b
        q3: q3f
      note: >
        Custom retrieval (Azure AI Search, private indexes, Foundry IQ, large-scale RAG)
        usually needs engineering partnership even for low-code makers. Plan Foundry or
        platform-team support for indexes, ACLs, and retrieval quality — or stay on Copilot
        Studio connectors when simpler grounding is enough.
    - when:
        q1: q1c
        q4: q4a
      note: >
        Professional developers building simple Q&A in Microsoft 365 often get more value
        from Agent Builder or a Microsoft 365 Agents Toolkit declarative agent (source control,
        API plugins, CI/CD on Copilot's orchestrator) than from a full Foundry custom engine.
        Escalate to Foundry only when you need your own runtime, models, or retrieval architecture.

  # Winner mismatch notes — persona, audience, or access. Supports legacy
  # `persona:` (q1 only) or full `when:` answer maps. Also used on entry-point
  # results when answers are empty (match on winner only).
  winner_persona_notes:
    - winner: foundry
      persona: q1a
      note: >
        Microsoft Foundry is the right platform for this scenario, but it requires
        professional development skills and Azure expertise. Consider partnering with
        your development team to build and maintain this agent.
    - winner: foundry
      persona: q1b
      note: >
        Microsoft Foundry fits this scenario's runtime needs, but it is a pro-code Azure
        platform. Low-code makers usually partner with professional developers for hosted
        agents, private networking, and custom retrieval — or stay on Copilot Studio when
        maker-led delivery is enough.
    - winner: copilot_studio
      when:
        q1: q1a
        q3: [q3c, q3f]
      note: >
        Copilot Studio can deliver this scenario, but Dataverse, custom connectors, APIs,
        or custom retrieval usually need IT or maker partnership for setup, ALM, and
        ongoing governance — plan that support before you build alone.
    - winner: copilot_studio
      when:
        q1: q1a
        q4: [q4c, q4d]
      note: >
        Copilot Studio is the right low-code home for actions and multi-agent business
        processes, but complex workflows still benefit from IT or maker partnership for
        connectors, environment strategy, and Copilot Credits governance.
    - winner: agent_builder
      when:
        q8: q8c
      note: >
        Agent Builder fits lightweight Microsoft 365 knowledge agents, but a department-wide
        audience usually outgrows Builder sharing and governance. Plan a path to Copilot Studio
        for managed deployment, DLP, and lifecycle controls.
    - winner: scout
      note: >
        Microsoft Scout is a Frontier preview. Confirm Frontier enrollment, Intune policy,
        attestation, and GitHub Copilot licensing before you rely on it — access is gated
        and capabilities can change.

################################################################################
# Conditional result callouts (unscored) — SharePoint tip, Toolkit path, etc.
# Evaluated after scoring; shown on the primary recommendation card only.
################################################################################

result_callouts:
  - id: sharepoint_site_tip
    winner_in: [agent_builder, copilot_studio]
    when:
      q8: q8a
      q3: q3a
      q4: [q4a, q4b, q4e]
    label: Consider SharePoint agents first
    summary: >
      For Q&A on a single SharePoint site or library, a SharePoint agent may be enough —
      no-code, grounded in that site, and available in SharePoint, Teams, and Microsoft 365
      Copilot. Site owners/admins enable agents; escalate to Agent Builder or Copilot Studio
      when you need multi-site grounding, actions, or broader governance.
    url: https://support.microsoft.com/office/get-started-with-sharepoint-agents-69e2faf9-2c1e-4baa-8305-23e625021bcf

  - id: toolkit_m365_extensibility
    winner_in: [copilot_studio, foundry]
    when:
      q1: q1c
      q2: q2a
      q4: [q4c, q4b, q4e]
    label: Microsoft 365 Agents Toolkit (declarative) may fit better
    summary: >
      Pro-dev + Microsoft 365 Copilot chat + API/actions often means a declarative agent or
      API plugin with Adaptive Cards and CI/CD — still on Copilot's orchestrator. Evaluate
      the Agents Toolkit before committing to a custom-engine Foundry path. Toolkit is
      unscored guidance in this advisor, not a fourth scored winner.
    url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agents-overview

  - id: toolkit_ab_prodev
    winner: agent_builder
    when:
      q1: q1c
    label: Prefer Agents Toolkit for pro-dev lifecycle
    summary: >
      Agent Builder is no-code only. Professional developers who need source control,
      API plugins, Adaptive Cards, or CI/CD while staying on the Microsoft 365 Copilot
      orchestrator should use the Microsoft 365 Agents Toolkit rather than stretching
      Builder — or move to Copilot Studio for governed low-code actions.
    url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agents-overview

################################################################################
# RECOMMENDATION COPY
################################################################################

recommendations:

  agent_builder:
    headline: Agent Builder
    description: No-code declarative agents inside Microsoft 365 Copilot — lightweight knowledge helpers grounded in Microsoft 365 content, scoped web, uploaded files, and admin-enabled Copilot connectors
    resources_url: https://microsoft.github.io/agent-resources/m365-copilot/#agent-builder
    scoring_summary: Best suited for no-code, small-team declarative agents inside Microsoft 365 Copilot (not the full declarative or pro-code extensibility surface).
    exploration_best_for: No-code declarative agents in Microsoft 365 Copilot
    exploration_summary: >
      Choose Agent Builder when you want no-code declarative agents inside Microsoft 365
      Copilot — not every declarative agent path. It is ideal for business users who need
      Q&A, summarization, lookup, or lightweight content helpers grounded in Microsoft 365
      content, scoped web, uploaded files, or admin-enabled Copilot connectors. It has no
      Actions; scenarios that call APIs or take actions move to Copilot Studio (or the
      Microsoft 365 Agents Toolkit for pro-code plugins still on the Copilot orchestrator).
    summary: >
      The no-code starting point for declarative knowledge agents inside Microsoft 365
      Copilot — not a stand-in for SharePoint agents, Agents Toolkit plugins, or custom-engine agents.
    best_for:
      - No-code creators building for themselves or a small internal team
      - Declarative agents that stay on Microsoft 365 Copilot's orchestrator and models
      - Agents grounded in Microsoft 365 content, scoped web, uploaded files, or admin-enabled Copilot connectors
      - Q&A, summarization, lookup, coaching, and lightweight document, chart, image, or data-analysis scenarios
    watch_out_for:
      - Agent Builder has no Actions — Learn sends action, API, and workflow scenarios to Copilot Studio
      - This is the no-code Builder path only — not SharePoint agents, not Agents Toolkit declarative projects, and not custom-engine agents
      - Included with Microsoft 365 Copilot capabilities for eligible seats — not a standalone unlimited builder license; sharing stays inside your organization
      - Can't be shared with people outside your organization
      - Broad department or organization-wide agents usually need Copilot Studio's deployment and governance controls
      - External business data must be available through Microsoft 365 Copilot connectors; direct APIs, Dataverse, custom databases, private search indexes, and custom retrieval require Copilot Studio or Foundry
      - Not suitable for custom action logic, approvals, branching workflows, event triggers, or external system updates
      - Outgrow Builder → copy or rebuild in Copilot Studio; need API plugins, Adaptive Cards, or CI/CD while staying on the Copilot orchestrator → Microsoft 365 Agents Toolkit
      - No evaluation or testing tools — quality assurance is manual
      - No lifecycle management — no versioning, environments, or CI/CD
      - Minimal observability — limited visibility into agent behavior and usage
    adjacent_paths:
      - label: SharePoint agents
        summary: >
          Site- or library-scoped Q&A with no-code setup; runs in SharePoint, Teams, and
          Microsoft 365 Copilot. Site owners or admins enable agents — prefer this when one
          site's content is enough before standing up Builder or Studio.
        url: https://support.microsoft.com/office/get-started-with-sharepoint-agents-69e2faf9-2c1e-4baa-8305-23e625021bcf
      - label: Microsoft 365 Agents Toolkit (declarative)
        summary: Pro-code declarative agents and API plugins with Adaptive Cards and CI/CD — still on the Copilot orchestrator, not a custom engine. Unscored adjacent path.
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agents-overview
      - label: Outgrow Builder
        summary: Move to Copilot Studio for actions, governance, and multi-channel publish; use Foundry only when you need your own runtime, models, or retrieval architecture.
        url: https://learn.microsoft.com/microsoft-copilot-studio/
    templates:
      - label: Career Coach
        description: Personalized career development plans, skill gap analysis, and actionable advice
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-career-coach
      - label: Corporate Communications Crafter
        description: On-brand internal and external communications — announcements, newsletters, exec updates
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-corporate-communications
      - label: Customer Insight Assistant
        description: Detailed customer profiles including industry, priorities, leadership, and competitors
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-customer-insight
      - label: Idea Coach
        description: Guided brainstorming sessions with creative exercises to develop and refine ideas
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-idea-coach
      - label: Interview Question Assistant
        description: Tailored, high-quality interview questions based on role and job description
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-interview-questions
      - label: Learning Coach
        description: Structured learning plans and topic summaries tailored to individual knowledge gaps
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-learning-coach
      - label: Meeting Coach
        description: Structured agendas, role assignments, and real-time guidance to run effective meetings
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-meeting-coach
      - label: Prompt Coach
        description: Guides users in crafting well-structured Copilot prompts through interactive feedback
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-prompt-coach
      - label: Request for Proposal Assistant
        description: Generates tailored RFP response drafts from existing proposal content and templates
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-rfp-assistant
      - label: Quiz Tutor
        description: Interactive quizzes based on training content to reinforce learning and knowledge retention
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-quiz-tutor
      - label: Scrum Assistant
        description: Real-time guidance on scrum ceremonies, backlog management, and Agile best practices
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-scrum-assistant
      - label: Text Translator Assistant
        description: Translates text, adjusts tone for professional communication, and improves writing quality
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-text-translator
      - label: Writing Coach
        description: Detailed feedback on clarity, coherence, grammar, and tone to elevate writing quality
        url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agent-template-writing-coach

  m365_copilot:
    headline: Microsoft 365 Copilot
    description: Built-in, permission-aware AI across Microsoft 365 Copilot Chat, Search, Word, Excel, PowerPoint, Outlook, Teams, Loop, Pages, Notebooks, Microsoft-built agents, and the Agent Store
    resources_url: https://microsoft.github.io/agent-resources/m365-copilot/
    scoring_summary: Fits scenarios where Microsoft 365 Copilot's built-in chat, search, app, notebook, Agent Store, and first-party agent capabilities already cover the need.
    exploration_best_for: Chat, Search, apps, and built-in agents across Microsoft 365
    exploration_summary: >
      Use Microsoft 365 Copilot when employees need built-in, permission-aware help
      across Copilot Chat, Copilot Search, Word, Excel, PowerPoint, Outlook, Teams,
      Loop, Pages, Notebooks, the Agent Store, and Microsoft-built agents like
      Researcher, Analyst, Facilitator, and Interpreter. Start in Chat for interactive
      work; escalate to Cowork for a delegated deliverable or to a built-in agent for
      specialized jobs — without treating Chat as the only surface.
    summary: >
      Best when built-in Microsoft 365 Copilot capabilities already meet most of
      what users need — chat, search, app-native assistance, collaborative pages
      and notebooks, Agent Store agents, and Microsoft-built agents grounded in each
      user's permitted work content, connected sources, and the web.
    # The entry-point wizard's task-type answer picks which surface inside
    # Microsoft 365 Copilot to start with. Copilot Chat and the built-in agents
    # are surfaces of this one product, not separate destinations.
    start_here:
      chat:
        label: Copilot Chat
        url: https://learn.microsoft.com/microsoft-365/copilot/microsoft-365-copilot-overview
        tagline: Ask, summarize, and draft in the flow of work
        description: >-
          The conversational front door to Microsoft 365 Copilot — you ask, iterate, and get
          answers, summaries, and drafts yourself, grounded in your email, meetings, files, and
          messages. Call a specialized agent from here whenever a task needs one.
      agents:
        label: Built-in agents — Researcher, Analyst, Facilitator, Interpreter
        url: https://learn.microsoft.com/microsoft-365/copilot/researcher-agent
        tagline: Purpose-built agents for specialized jobs
        description: >-
          Start with the agent built for the job — Researcher for source-cited deep research,
          Analyst for data analysis in Python, Facilitator for meeting notes and follow-ups,
          Interpreter for live translation. They run inside Microsoft 365 Copilot alongside chat,
          so you can move between them without switching products.

    best_for:
      - Ad hoc, user-initiated questions, summaries, and drafting in Chat
      - Working through a task yourself rather than handing it off
      - Interactive deep research with Researcher (hand off a research deliverable to Cowork when you want it run for you)
      - Specialized jobs a Microsoft-built agent or Agent Store agent already handles
      - Grounded in your Microsoft 365 context (email, meetings, files, messages)
    watch_out_for:
      - You stay in the loop — it does not run a multi-step task end to end on its own
      - Not always-on or proactively monitoring
      - Requires Microsoft 365 Copilot seating/metering appropriate to chat, built-in agents, and Agent Store agents in your tenant
      - Start in Chat, then escalate to a built-in agent, Cowork, or Scout when the job outgrows turn-by-turn help
      - Use Cowork instead when you want to delegate a bounded multi-step deliverable or a scheduled/event-triggered Microsoft 365 job
      - Use Scout instead when you need always-on personal Autopilot across desktop, browser, local files, and Microsoft 365
    adjacent_paths:
      - label: Start in Chat, escalate when needed
        summary: Use Copilot Chat for interactive work; open Researcher or another built-in agent for specialized jobs; hand off multi-step or scheduled Microsoft 365 work to Cowork.
        url: https://learn.microsoft.com/microsoft-365/copilot/microsoft-365-copilot-overview
      - label: SharePoint agents
        summary: When the need is Q&A on one site or library, try a SharePoint agent before building a custom agent.
        url: https://support.microsoft.com/office/get-started-with-sharepoint-agents-69e2faf9-2c1e-4baa-8305-23e625021bcf

    first_party_label: Built-in Copilot capabilities and agents
    first_party_agents:
      - label: Copilot Chat
        description: Permission-aware chat for drafting, summarizing, answering questions, and working across Microsoft 365 content and the web — agents can render interactive UI like forms and cards inline via MCP Apps
        url: https://learn.microsoft.com/microsoft-365/copilot/microsoft-365-copilot-overview
      - label: Copilot Search
        description: AI-powered universal search across Microsoft 365 and connected third-party sources, with natural-language queries and handoff to chat
        url: https://learn.microsoft.com/microsoft-365/copilot/microsoft-365-copilot-search
      - label: Copilot Pages and Notebooks
        description: Persistent, shareable workspaces for synthesizing content and grounding Copilot on curated material; stored in SharePoint Embedded/Loop containers
        url: https://learn.microsoft.com/microsoft-365/loop/cpcn-requirements
      - label: Agent Store
        description: Discover and add first- and third-party agents inside Microsoft 365 Copilot
        url: https://learn.microsoft.com/microsoft-365/copilot/copilot-agent-store
      - label: Sales Agent
        description: Seller productivity in Teams, Outlook, and CRM apps
        url: https://learn.microsoft.com/microsoft-sales-copilot/
      - label: Service Agent
        description: Customer service agent assistance across support channels
        url: https://learn.microsoft.com/microsoft-copilot-service/
      - label: Finance Agent
        description: Financial workflows, analysis, and reconciliation in Excel and Outlook
        url: https://learn.microsoft.com/copilot/finance/
      - label: Employee Self-Service Agent
        description: HR and IT self-service within Teams for policies, FAQs, and requests
        url: https://learn.microsoft.com/copilot/microsoft-365/employee-self-service/overview
      - label: SharePoint Agent
        description: Q&A grounded in a specific SharePoint site or document library
        url: https://support.microsoft.com/office/get-started-with-sharepoint-agents-69e2faf9-2c1e-4baa-8305-23e625021bcf
      - label: Facilitator Agent
        description: Meeting facilitation, collaborative real-time notes, Q&A, timeline markers, action items, and preview Planner/Word integrations in Teams
        url: https://learn.microsoft.com/microsoftteams/facilitator-teams
      - label: Researcher Agent
        description: Performs deeper, source-cited, multi-step research across web and work content to produce structured reports, visuals, and recommendations
        url: https://learn.microsoft.com/microsoft-365/copilot/researcher-agent
      - label: Analyst Agent
        description: Transforms complex data into clear insights, charts, and visualizations using Python
        url: https://techcommunity.microsoft.com/blog/microsoft365copilotblog/analyst-agent-in-microsoft-365-copilot/4397191
      - label: Interpreter Agent
        description: Real-time speech-to-speech interpretation in Teams meetings across nine languages, with optional voice simulation and included monthly capacity
        url: https://learn.microsoft.com/microsoftteams/interpreter-agent-teams
      - label: Project Manager Agent
        description: Automates project plan creation, task tracking, and status reporting in Planner (preview)
        url: https://aka.ms/agents/ProjectManagerDocs
      - label: Channel Agent
        description: Teams channel expert for summarizing conversations, managing tasks, and boosting productivity (preview)
        url: https://support.microsoft.com/office/get-started-with-channel-agent-for-teams-channels-b85945cf-deef-4f1e-9db1-66e1a23b6a65
      - label: Community Agent
        description: Accelerates knowledge sharing and surfaces expertise across org communities in Viva Engage (preview)
        url: https://learn.microsoft.com/viva/engage/ai-technology-with-viva-engage/agents-community-network-deployment-config

  copilot_studio:
    headline: Copilot Studio
    description: Governed low-code enterprise agents with actions, triggers, connectors, multi-agent orchestration, evaluation, monitoring, and multi-channel deployment
    resources_url: https://microsoft.github.io/agent-resources/copilot-studio/
    scoring_summary: The governed low-code platform for enterprise agents that need actions, workflows, connectors, multi-agent business orchestration, evaluation, monitoring, and broad deployment.
    exploration_best_for: Governed low-code agents — actions, triggers, connectors, multi-channel
    exploration_summary: >
      Choose Copilot Studio when you need governed low-code agents that go beyond
      knowledge lookup — actions, event triggers, connectors, child agents and A2A
      (multi-agent orchestration is GA), evaluation, monitoring, and multi-channel
      publish. Great for makers and IT teams. Enterprise desktop automation uses
      computer use / Windows 365 for Agents MCP; personal always-on desktop Autopilot
      is Scout, not Studio.
    summary: >
      The best low-code platform for governed enterprise agents — connect to outside
      systems, automate business processes, orchestrate multiple agents, evaluate
      quality, monitor behavior, and deploy to websites, Teams, Microsoft 365, and more.
    best_for:
      - Low-code makers and IT pros
      - Agents connecting to external APIs, CRM, ERP, Dataverse, databases, MCP servers, or custom connectors
      - Event-triggered, scheduled, or user-triggered workflows with actions, branching, human review, and approvals
      - Multi-agent orchestration (GA) — child agents, connected Copilot Studio agents, and A2A for department or business processes
      - Automating legacy web or desktop apps with computer use and Windows 365 for Agents (GA enterprise agent automation — not personal Scout Autopilot)
      - Multi-turn generative orchestration with Microsoft IQ context; optional per-user memory and skills in the new agent experience (preview) — not full classic-topic parity
      - Internal and external-facing deployment
      - Built-in evaluation test sets, activity maps, analytics, monitoring, and tenant-wide agent inventory
    watch_out_for:
      - Choose the harness when you create the agent — GitHub Copilot, standard, and Copilot chat harness agents can't be transferred between harnesses
      - GitHub Copilot harness agents and workflows consume Copilot Credits while building, previewing, testing, evaluating, and running in production
      - Complex ML pipelines or custom model training require Foundry
      - Code-first multi-agent systems, custom protocols, high-scale hosted agents, or bring-your-own orchestrator belong in Foundry — not because "multi-agent" alone requires it
      - Supports curated GA, preview, and experimental models, including deep reasoning models; use Foundry for arbitrary bring-your-own model hosting, custom model training, model routing, private networking, and full runtime control
      - New agent experience (GitHub Copilot-style harness), skills, and memory are preview capabilities with lifecycle limits — do not assume classic topic parity or long retention
      - Connecting Foundry IQ knowledge from Copilot Studio remains preview where labeled as such in Learn
      - Computer use (GA) still needs credential, supervision, access-control, observability, and cost governance
      - Copilot Credits scale with generative answers, agent actions, tenant graph grounding, workflows, reasoning models, voice, and computer use — budget before wide rollout
      - Pro-dev building API plugins or CI/CD declarative agents for Microsoft 365 Copilot should also evaluate Microsoft 365 Agents Toolkit before defaulting to Foundry
    harnesses:
      github_copilot:
        label: GitHub Copilot harness
        url: https://learn.microsoft.com/microsoft-copilot-studio/agents-experience/overview
        tagline: Managed adaptive execution for reasoning-heavy, multi-step work
        description: >
          Start here when the agent should take a goal, plan the steps, use several tools
          or agents, create or edit Office and PDF files, adapt when conditions change,
          and recover when a step fails. Tasks run in a secure Copilot Studio sandbox.
        considerations:
          - Harness choice is fixed for the agent; it can't later transfer to the standard or Copilot chat harness
          - Copilot Credits apply during building, previewing, testing, evaluating, and production use
      standard:
        label: Standard harness
        url: https://learn.microsoft.com/microsoft-copilot-studio/harnesses-overview
        tagline: Predictable topic-driven conversations and explicit rules
        description: >
          Start here when the agent should follow defined topics, branches, prompts, and
          repeatable conversation paths rather than decide its own plan dynamically.
        considerations:
          - Prefer the workflow experience instead when the primary requirement is scheduled or event-triggered deterministic automation
          - Harness choice is fixed for the agent and should be validated before implementation
      copilot_chat:
        label: Copilot chat harness
        url: https://learn.microsoft.com/microsoft-copilot-studio/microsoft-365-copilot-extend-with-agents
        tagline: Internal knowledge extensions inside Microsoft 365 Copilot Chat
        description: >
          Start here when employees need Microsoft 365 Copilot Chat grounded in your
          organization's knowledge without leaving their everyday Microsoft 365 experience.
        considerations:
          - Publishes to internal teams rather than external customers
          - Agent Builder remains the faster option for the simplest small-team no-code scenario
      workflow:
        label: Copilot Studio workflow
        url: https://learn.microsoft.com/microsoft-copilot-studio/workflows-experience/flows-overview
        tagline: Deterministic automation with triggers, branching, AI actions, and agent handoffs
        description: >
          Start with a workflow when a schedule, event, user, or agent should trigger a
          predictable sequence of connector actions, control logic, human input, and AI steps.
        considerations:
          - Each production action consumes Copilot Studio capacity, so monitor environment allocation and enforcement
          - Use an adaptive GitHub Copilot harness agent when the process must decide and re-plan rather than follow a defined path
    adjacent_paths:
      - label: Use Microsoft 365 Agents Toolkit instead when…
        summary: You are a pro developer shipping declarative agents or API plugins into Microsoft 365 Copilot with source control and CI/CD — still on Copilot's orchestrator.
        url: https://learn.microsoft.com/microsoftteams/platform/toolkit/overview-agents-toolkit
      - label: Use Foundry instead when…
        summary: You need your own code runtime, models, private networking, custom retrieval architecture, or high-scale hosted agents — runtime ownership, not just multi-agent.
        url: https://microsoft.github.io/agent-resources/microsoft-foundry/
    persona_tips:
      q1c: >
        🛠️ <strong>Developer tip:</strong> You can build Copilot Studio agents in YAML using the
        <a href="https://learn.microsoft.com/microsoft-copilot-studio/authoring-overview" target="_blank" rel="noopener noreferrer">Copilot Studio extension for VS Code</a>.
        For pro-code declarative agents and API plugins that stay on the Microsoft 365 Copilot
        orchestrator, also see the
        <a href="https://learn.microsoft.com/microsoft-365/copilot/extensibility/agents-overview" target="_blank" rel="noopener noreferrer">Microsoft 365 Agents Toolkit</a>.

  foundry:
    headline: Microsoft Foundry
    description: Pro-code managed agent runtime for custom engines, models, retrieval, identity, networking, and Azure-scale observability
    resources_url: https://microsoft.github.io/agent-resources/microsoft-foundry/
    scoring_summary: The right choice when production agents need runtime ownership — code-first control, managed hosting, custom retrieval, identity, networking, observability, or strict compliance.
    exploration_best_for: Pro-code managed runtime — custom engine, models, retrieval at Azure scale
    exploration_summary: >
      Choose Microsoft Foundry when your team needs a managed agent runtime with
      full developer control — prompt agents, hosted code agents, custom protocols,
      Foundry models, toolboxes, MCP, Foundry IQ, private networking, agent identity,
      tracing, evaluation, monitoring, and publishing to Microsoft 365 or custom apps.
      Foundry wins on runtime ownership, not merely because a scenario says "multi-agent."
      Built for professional developers, architects, and ML engineers.
    summary: >
      The right choice when your team needs to own the runtime — managed endpoints,
      custom code and protocols, model catalog access, custom retrieval, agent identity,
      private networking, tracing, evaluation, and monitoring at Azure scale.
    best_for:
      - Professional developers, architects, and ML engineers
      - Runtime ownership — own code, models, private networking, or managed custom hosting
      - Prompt agents when you want Foundry to run the agent without maintaining application code
      - Hosted agents when you need your own code, Agent Framework, LangGraph, OpenAI Agents SDK, Anthropic Agent SDK, GitHub Copilot SDK, or custom frameworks
      - Code-first multi-agent systems with custom protocols or high-scale hosted agents
      - Agents embedded in custom-built applications, backend services, APIs, webhooks, voice systems, or custom protocols
      - Custom RAG and enterprise retrieval with Foundry IQ, Azure AI Search, Azure Blob Storage, SharePoint, OneLake, web sources, citations, ACLs, and Purview sensitivity labels
      - Foundry Toolboxes and MCP-compatible tool bundles with centralized authentication, versioning, and policy enforcement
      - Dedicated Microsoft Entra agent identities, RBAC, private networking, content filters, and bring-your-own Azure resources
      - Full development lifecycle — versioning, stable endpoints, rollback, publishing, tracing, evaluation, monitoring, and Application Insights integration
      - Agent Optimizer evaluate-and-optimize loop (preview) where available
      - Publishing agents to Microsoft 365 Copilot, Teams, custom apps, services, and the Entra Agent Registry
      - Edge/local and disconnected patterns via Foundry Local (including Foundry Local on Azure Local for air-gapped or on-premises control planes)
      - Strict compliance, data residency, private networking, or security requirements
    watch_out_for:
      - Higher implementation complexity and time-to-value
      - Requires Azure expertise and development resources
      - Azure consumption — hosted agent compute, networking, model tokens, and retrieval indexes drive cost beyond seats alone
      - Hosted agents add container compute, framework, protocol, and operational responsibilities
      - Agent Optimizer, some tools, A2A, and portions of agentic retrieval may be preview depending on API version, region, and setup
      - Multi-agent alone is not a Foundry requirement — Copilot Studio multi-agent orchestration is GA for low-code business processes
      - Use Copilot Studio for low-code departmental workflows, Dataverse/custom connector automations, governed multi-agent business orchestration, and fast maker-led delivery
      - Use Microsoft 365 Agents Toolkit for pro-code declarative agents and API plugins that stay on the Microsoft 365 Copilot orchestrator (unscored adjacent path)
      - Use Agent Builder for simple no-code Microsoft 365 Copilot knowledge agents
    adjacent_paths:
      - label: Use Microsoft 365 Agents Toolkit instead when…
        summary: You need pro-code declarative agents or API plugins inside Microsoft 365 Copilot without bringing your own orchestrator.
        url: https://learn.microsoft.com/microsoftteams/platform/toolkit/overview-agents-toolkit
      - label: Use Copilot Studio instead when…
        summary: Makers need governed actions, connectors, channels, and multi-agent business orchestration without owning Azure runtime plumbing.
        url: https://microsoft.github.io/agent-resources/copilot-studio/

  # ---------------------------------------------------------------------------
  # Ready-made agent entry points (entry-point wizard only) — Cowork and Scout
  # are places an end user goes to get work done, not platforms you build agents
  # on. (The wizard's third destination, Microsoft 365 Copilot, is defined above
  # because it is also a scored-wizard platform.) They are NOT part of the scored wizard and
  # never appear in meta.platforms. They are reached only via the prescreen
  # "Help me find the right place to get work done" path, which asks about the
  # work pattern (involvement, cadence, reach) instead of product names.
  # ---------------------------------------------------------------------------

  cowork:
    headline: Copilot Cowork
    description: Delegate multi-step Microsoft 365 work — one-shot deliverables, scheduled prompts, and event-driven tasks — with approvals and human-in-the-loop control
    resources_url: https://learn.microsoft.com/microsoft-365/copilot/cowork/
    scoring_summary: Best for delegating multi-step Microsoft 365 work on demand, on a schedule, or from M365 events.
    exploration_best_for: Delegate multi-step Microsoft 365 work — including schedules and triggers
    exploration_summary: >
      Cowork acts as your AI delegate inside Microsoft 365 Copilot — you describe an
      outcome, it creates a plan, works through the steps, and pauses for approval
      before sensitive actions. It supports one-shot deliverables, scheduled prompts
      (daily briefings, inbox triage), and event-driven Microsoft 365 tasks. Ideal for
      meeting prep, coordinated document sets, and deep-research handoffs, with
      human-in-the-loop checkpoints. Not a desktop/browser/local runtime — that is Scout.
    summary: >
      Delegate multi-step Microsoft 365 work — finish-and-hand-back jobs, recurring
      schedules, or inbox/Teams-triggered tasks — with approvals before sensitive actions.
    best_for:
      - Handing off a bounded, multi-step Microsoft 365 deliverable (board packs, meeting packets, coordinated docs)
      - Recurring Microsoft 365 tasks — daily briefings, status roundups, inbox triage — via scheduled prompts
      - Event-driven Microsoft 365 work (for example when a VIP emails you or a Teams message arrives)
      - Deep research as a handed-off deliverable (interactive research stays on Microsoft 365 Copilot · Researcher)
      - Human-in-the-loop control — progress updates, approval checkpoints, pause/resume/cancel
      - Grounded in your Microsoft 365 context (email, meetings, files, messages) via Work IQ
      - Extending the experience with custom skills and plugins
    watch_out_for:
      - Runs on demand, on a schedule, or from Microsoft 365 events you configure — but is not the always-on cross-environment personal Autopilot (that is Scout)
      - Centered on Microsoft 365 — no desktop, shell, browser, or local-file runtime
      - Usage-based billing through Copilot Credits — heavy multi-step or scheduled runs consume credits
      - Actions like sending email or posting in Teams require explicit approval
      - Use Microsoft 365 Copilot (Copilot Chat / Researcher) instead when you want to stay interactive
      - Use Scout instead when work must reach desktop, browser, local files, or shell, or needs personal Autopilot identity across environments

  scout:
    headline: Microsoft Scout
    description: Always-on personal Autopilot desktop app (Frontier preview) across files, shell, browser, and Microsoft 365 — gated by Frontier enrollment, Intune, and licensing
    resources_url: https://learn.microsoft.com/microsoft-scout/overview
    scoring_summary: Best for always-on, proactive personal Autopilot across desktop, browser, local files, and Microsoft 365.
    exploration_best_for: Always-on personal Autopilot (Frontier preview)
    exploration_summary: >
      Scout is Microsoft's personal Autopilot — an always-on agent with its own
      identity that works across files, shell, browser, and Microsoft 365. Ideal for
      proactive monitoring and follow-through that spans local and cloud environments.
      Frontier preview: enrollment, Intune policy, attestation, and GitHub Copilot
      licensing gates apply. Enterprise UI automation of legacy apps is Copilot Studio
      computer use — not Scout.
    summary: >
      An always-on personal Autopilot that proactively keeps work moving across desktop,
      browser, local files, and Microsoft 365 — even when you are not prompting it.
    best_for:
      - Always-on personal Autopilot rather than one-shot or M365-only scheduled jobs
      - Proactive monitoring and follow-through that may span environments
      - Acting across local files, shell commands, browser automation, code, and Microsoft 365
      - Delegating work to specialized sub-agents
      - Monitoring for risks like stalled decisions and upcoming deliverables
      - Extending the experience with custom skills and plugins
    watch_out_for:
      - Frontier preview only — not GA; capabilities, access, and commercialization details can change
      - Gated through Frontier enrollment, Intune policy, attestation, and GitHub Copilot licensing — confirm access before recommending widely
      - Desktop application for Windows and macOS
      - Sensitive actions (sending email, writing files, running commands) require approval
      - Use Cowork instead for Microsoft 365-only one-shot, scheduled, or event-triggered deliverables
      - Use Copilot Studio computer use / Windows 365 for Agents (GA) for enterprise agent automation of legacy desktop UI — Scout is personal Autopilot, not that path
      - Use Microsoft 365 Copilot (Copilot Chat) instead when you just want to ask and iterate yourself

################################################################################
# Explore page groups — the two lanes on "Explore ways to use or build agents".
# Copy lives here, not in renderExploration(), so platform wording stays in one
# place. `platforms` are recommendation ids, rendered in the order listed.
################################################################################

exploration_groups:
  - title: Use agents
    description: >-
      Start with built-in or ready-made agents that work inside Microsoft 365 or
      across your work environment.
    platforms: [m365_copilot, cowork, scout]
  - title: Build agents
    description: >-
      Choose a platform for creating, extending, governing, and operating agents for
      your scenario. Agent Builder is the no-code declarative path inside Microsoft 365
      Copilot — not every declarative or pro-code Copilot extensibility option.
    platforms: [agent_builder, copilot_studio, foundry]

# Header for the unscored adjacent_build_paths lane on the same page.
exploration_adjacent_group:
  title: Related build paths
  description: >-
    These are adjacent options in Microsoft's build taxonomy. They are not separate
    scored winners in this advisor, but they matter when Agent Builder, Copilot Studio,
    or Foundry alone is not the right solution.

################################################################################
# Adjacent build paths (unscored) — surfaced in Explore and as card footnotes.
# Not separate scored winners; clarify Builder ≠ all declarative agents.
################################################################################

adjacent_build_paths:
  - id: sharepoint_agents
    label: SharePoint agents
    exploration_best_for: Site- or library-scoped Q&A
    summary: >
      No-code agents grounded in a SharePoint site or library. Run in SharePoint, Teams,
      and Microsoft 365 Copilot when the need is scoped content Q&A — not a full Agent
      Builder project or Copilot Studio solution. Site owners or admins enable agents;
      check tenant policies before rollout.
    url: https://support.microsoft.com/office/get-started-with-sharepoint-agents-69e2faf9-2c1e-4baa-8305-23e625021bcf
  - id: agents_toolkit_declarative
    label: Microsoft 365 Agents Toolkit (declarative)
    exploration_best_for: Pro-code plugins on the Copilot orchestrator
    summary: >
      Pro-code declarative agents and API plugins with Adaptive Cards, source control,
      and CI/CD — still using Microsoft 365 Copilot's orchestrator and models. Prefer
      this over Foundry when the goal is Copilot extensibility, not a custom engine.
      Unscored in this advisor unless a future iteration adds a fourth build dimension.
    url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/agents-overview
  - id: custom_engine_agents
    label: Custom engine agents
    exploration_best_for: Bring-your-own orchestrator and models
    summary: >
      When you bring your own orchestrator, models, or hosted runtime, the path is
      Microsoft Foundry and the Agents SDK — not Agent Builder and not Toolkit-only
      declarative projects.
    url: https://learn.microsoft.com/microsoft-365/copilot/extensibility/overview-custom-engine-agent

################################################################################