ms-ai-architect/skills/ms-ai-engineering/references/agent-orchestration/agent-ecosystem-and-plugin-marketplace.md

Agent Ecosystem and Plugin Marketplace Patterns

Last updated: 2026-02 Status: GA Category: Agent Orchestration & Automation Type: reference

---

Innhold

• Introduksjon
• Kjernekomponenter
• Plugin Discovery Mechanisms
• Capability Advertisement
• Dependency Management
• Version Compatibility
• Distribution Patterns
• Governance for Agent Ecosystems
• Norsk offentlig sektor
• Beslutningsrammeverk
• For arkitekten

Introduksjon

AI-agentøkosystemer representerer en paradigme-endring fra isolerte AI-løsninger til sammenkoblede plattformer der agenter, plugins og tredjepartsintegrasjoner kan oppdages, distribueres og kombineres dynamisk. Microsoft 365 Copilot-økosystemet er det mest modne eksemplet, med en unified app-modell der agenter er apps som distribueres gjennom Microsoft 365 admin center, sideloades for testing, eller publiseres i Microsoft Commercial Marketplace.

Microsoft har etablert et komplett økosystem for agentdistribusjon: Copilot Studio for agent-bygging, Microsoft 365 Agents Toolkit for pro-code-utvikling, Partner Center for ISV-publisering, og M365 admin center for enterprise-governance. Agenter pakkes som standard Microsoft 365-apps med manifest-filer og ikoner, og distribueres gjennom de samme kanalene som Teams-apps og Outlook-tillegg. Dette gir organisasjoner en sentralisert plattform for å administrere, godkjenne og distribuere AI-kapabiliteter.

For organisasjoner som bygger interne agentøkosystemer gir dette mønsteret en modell for hvordan man designer plugin-discovery, kapabilitetser, versjonshåndtering og governance. Enten du bygger for Microsoft Commercial Marketplace eller for intern distribusjon, er prinsippene de samme: standardiserte grensesnitt, sentralisert governance og brukersentrert oppdagelse.

Kjernekomponenter

Komponent	Formål	Teknologi
Plugin Discovery	Oppdagelse av tilgjengelige agenter/plugins	M365 admin center, Copilot pane
Capability Advertisement	Deklarering av agentkapabiliteter	Agent manifest, OpenAPI spec
Dependency Management	Håndtere avhengigheter mellom agenter	App package, connectors
Version Compatibility	Versjonering og kompatibilitet	Manifest versioning, API versioning
Distribution	Publisering og distribusjon	Partner Center, organizational catalog
Governance	Styring av agentøkosystemet	M365 admin center, Copilot Studio

Plugin Discovery Mechanisms

Microsoft 365 agentoppdagelse

Oppdagelseveier for brukere:

1. Copilot Chat panel (høyre side)
   → Viser installerte agenter direkte i Copilot UI
   → Brukere kan bla og velge agenter

2. @-mention i Copilot
   → Brukere skriver @agentname for direkte invokasjon
   → Autocomplete viser tilgjengelige agenter

3. Microsoft 365 App Store
   → Søk og installér agenter som M365-apps
   → Kombinerer Teams-apps, Outlook-tillegg og Copilot-agenter

4. IT-administrert distribusjon
   → Admin pre-installerer agenter for brukergrupper
   → Brukere ser agenter automatisk

Programmatisk plugin-discovery

# Internt agentøkosystem: Plugin registry
class AgentPluginRegistry:
    """Sentralisert registrer for agentplugins"""

    def __init__(self, cosmos_client):
        self.container = cosmos_client.get_database_client("ecosystem") \
            .get_container_client("plugins")

    async def register(self, plugin: dict):
        """Registrer ny agent/plugin i økosystemet"""
        await self.container.upsert_item({
            "id": plugin["id"],
            "name": plugin["name"],
            "version": plugin["version"],
            "description": plugin["description"],
            "capabilities": plugin["capabilities"],
            "api_spec_url": plugin["api_spec_url"],
            "auth_requirements": plugin["auth_requirements"],
            "supported_intents": plugin["supported_intents"],
            "health_check_url": plugin["health_check_url"],
            "owner": plugin["owner"],
            "status": "active",
            "registered_at": datetime.utcnow().isoformat(),
            "compatibility": {
                "min_platform_version": "2.0",
                "supported_channels": ["teams", "copilot", "web"]
            }
        })

    async def discover(
        self,
        intent: str = None,
        capability: str = None,
        channel: str = None
    ) -> list:
        """Oppdage relevante plugins basert på kontekst"""
        query = "SELECT * FROM c WHERE c.status = 'active'"
        params = []

        if intent:
            query += " AND ARRAY_CONTAINS(c.supported_intents, @intent)"
            params.append({"name": "@intent", "value": intent})
        if capability:
            query += " AND ARRAY_CONTAINS(c.capabilities, @cap)"
            params.append({"name": "@cap", "value": capability})
        if channel:
            query += (" AND ARRAY_CONTAINS("
                "c.compatibility.supported_channels, @channel)")
            params.append({"name": "@channel", "value": channel})

        return [item async for item in
            self.container.query_items(query, parameters=params)]

Capability Advertisement

Agent manifest-standard

{
    "$schema": "https://schemas.microsoft.com/agent/v2.1/manifest.json",
    "manifestVersion": "2.1",
    "id": "no.ddt.agent.byggesak",
    "version": "1.3.0",
    "name": {
        "short": "Byggesak-agent",
        "full": "Byggesaksbehandling AI-assistent"
    },
    "description": {
        "short": "Hjelper med byggesaker og regelverk",
        "full": "AI-assistent for byggesaksbehandling. Gir veiledning om plan- og bygningsloven, kommunale reguleringsplaner, og saksbehandlingsprosedyrer."
    },
    "capabilities": {
        "knowledge_sources": [
            "plan-og-bygningsloven",
            "kommunale-reguleringsplaner",
            "byggesak-veileder"
        ],
        "actions": [
            {
                "id": "searchRegulations",
                "description": "Søk i regelverk for byggesaker",
                "api": "openapi",
                "spec_url": "/api/regulations/openapi.json"
            },
            {
                "id": "checkBuildingStatus",
                "description": "Sjekk status på byggesak",
                "api": "openapi",
                "spec_url": "/api/cases/openapi.json"
            }
        ],
        "supported_intents": [
            "byggetillatelse",
            "reguleringsplan",
            "nabovarsling",
            "dispensasjon"
        ],
        "languages": ["nb-NO", "nn-NO", "en-US"]
    },
    "authorization": {
        "type": "entra_id",
        "required_roles": ["BuildingCase.Read"],
        "data_classification": "intern"
    },
    "deployment": {
        "channels": ["teams", "copilot", "web"],
        "min_license": "M365-E5",
        "region_requirements": ["norway-east"]
    }
}

OpenAPI-basert capability advertisement

# OpenAPI spec for agent-kapabiliteter
openapi: 3.0.0
info:
  title: Byggesak Agent API
  version: 1.3.0
  description: |
    API for byggesaksbehandling AI-assistent.
    Bruk dette APIet når brukeren spør om byggesaker,
    regelverk eller saksbehandlingsprosedyrer.
  x-agent-config:
    model_recommendation: gpt-4o
    max_response_tokens: 800
    requires_human_review: true

paths:
  /api/regulations/search:
    get:
      operationId: searchRegulations
      summary: Søk i byggesaksregelverk
      description: |
        Søk etter relevante paragrafer og bestemmelser
        i plan- og bygningsloven og forskrifter.
      parameters:
        - name: query
          in: query
          required: true
          schema:
            type: string
          description: Fritekst-søk i regelverket
        - name: category
          in: query
          schema:
            type: string
            enum: [lov, forskrift, veileder, rundskriv]

Dependency Management

Agent-avhengigheter

# Håndtere avhengigheter mellom agenter og plugins
class DependencyResolver:
    def __init__(self, registry: AgentPluginRegistry):
        self.registry = registry

    async def resolve_dependencies(
        self, agent_id: str
    ) -> list:
        """Resolv og valider alle avhengigheter for en agent"""
        agent = await self.registry.get(agent_id)
        dependencies = agent.get("dependencies", [])
        resolved = []

        for dep in dependencies:
            plugin = await self.registry.discover(
                capability=dep["capability"]
            )
            if not plugin:
                raise DependencyError(
                    f"Manglende avhengighet: {dep['capability']}"
                )

            # Sjekk versjonskompatibilitet
            available = plugin[0]
            if not self._is_compatible(
                dep.get("min_version", "0.0.0"),
                available["version"]
            ):
                raise VersionError(
                    f"Plugin {available['name']} versjon "
                    f"{available['version']} er for gammel. "
                    f"Krever >= {dep['min_version']}"
                )

            resolved.append(available)

        return resolved

    def _is_compatible(
        self, required: str, available: str
    ) -> bool:
        from packaging import version
        return version.parse(available) >= version.parse(required)

Version Compatibility

Semantic versioning for agenter

# Versjoneringsstrategi for agentøkosystem
class AgentVersionManager:
    """Håndterer versjonering og kompatibilitet"""

    def validate_upgrade(
        self, current: str, target: str
    ) -> dict:
        """Validér om oppgradering er trygg"""
        from packaging.version import Version
        curr = Version(current)
        targ = Version(target)

        return {
            "is_major": targ.major > curr.major,
            "is_minor": targ.minor > curr.minor and targ.major == curr.major,
            "is_patch": targ.micro > curr.micro and targ.minor == curr.minor,
            "breaking_changes": targ.major > curr.major,
            "requires_testing": targ.major > curr.major or targ.minor > curr.minor,
            "auto_deploy_safe": targ.micro > curr.micro
                and targ.minor == curr.minor
                and targ.major == curr.major
        }

API-versjonering for plugin-grensesnitt

Versjonsendring	Eksempel	Handling
Patch (1.0.x)	Bugfix i responser	Automatisk utrulling
Minor (1.x.0)	Ny capability lagt til	Test + admin-godkjenning
Major (x.0.0)	Breaking API-endring	Full testing + migreringsveiledning

Distribution Patterns

Microsoft Commercial Marketplace

ISV publiseringsprosess:

1. Utvikle    → Bygg agent med Agents Toolkit / Copilot Studio
2. Teste      → Sideload og test i M365 tenant
3. Validere   → Oppfyll store submission requirements
4. Publisere  → Submit via Partner Center
5. Distribuere → Tilgjengelig i M365 App Store
6. Administrere → Oppdateringer via Partner Center

Krav for marketplace:
- Microsoft Partner Network medlemskap
- App validation retningslinjer
- Copilot-spesifikke UX-krav
- Sikkerhet og personvern-dokumentasjon

Intern distribusjon (organizational catalog)

# Automatisert intern distribusjon
class InternalAgentDistributor:
    """Distribuér agenter til organisasjonens M365 tenant"""

    async def publish_to_org_catalog(
        self, agent_package: bytes, metadata: dict
    ):
        """Publiser agent til organizational catalog"""
        # 1. Valider pakken
        validation = await self.validate_package(agent_package)
        if not validation.is_valid:
            raise ValidationError(validation.errors)

        # 2. Sikkerhetsskanning
        security = await self.security_scan(agent_package)
        if security.has_issues:
            raise SecurityError(security.findings)

        # 3. Last opp til organizational catalog
        await self.upload_to_catalog(
            package=agent_package,
            metadata=metadata,
            approval_required=True  # Admin-godkjenning påkrevd
        )

        # 4. Varsle admin om godkjenning
        await self.notify_admin(
            f"Ny agent '{metadata['name']}' venter på godkjenning"
        )

Governance for Agent Ecosystems

Admin-kontroller

M365 Admin Center agent governance:

1. Agent synlighet
   → Kontroller hvilke agenter som er tilgjengelige
   → Per-bruker og per-gruppe styring

2. Data access kontroller
   → Gjennomgå datapermissions per agent
   → Godkjenn/avslå datatilgang

3. Usage analytics
   → Spor bruk per agent, per bruker, per avdeling
   → Identifiser populære og ubrukte agenter

4. Compliance monitoring
   → Verifiser at agenter oppfyller organisasjonens policyer
   → Automatisert compliance-sjekk

Internt agent-kvalitetsprogram

Fase	Krav	Verifikasjon
Utvikling	Følg org-standarder for agent-utvikling	Code review
Testing	Bestå evalueringssett med > 80% kvalitet	Automatisert evaluering
Sikkerhet	Gjennomfør sikkerhetsgjennomgang	Red teaming rapport
Compliance	Oppfyll regulatoriske krav	Compliance checklist
Godkjenning	Admin-godkjenning for distribusjon	Admin approval workflow
Produksjon	Continuous evaluation og monitoring	Dashboards + alerting

Norsk offentlig sektor

Aspekt	Krav	Implementering
Anskaffelse	Anskaffelsesloven	Rammeavtale for agenter/plugins
Kvalitetssikring	Digdir kvalitetskrav	Testing mot evalueringssett
Deling	Felles komponenter	Fellesløsninger via Digdir
Sikkerhetsgodkjenning	NSM	Sikkerhetsgjennomgang per agent
Universell utforming	WCAG 2.1	Tilgjengelighetstest av agentgrensesnitt

Felles agentøkosystem for offentlig sektor

Visjon: Deling av agenter mellom offentlige virksomheter

1. Sentral agent-katalog (Digdir / DFD)
   → Offentlige virksomheter publiserer gjenbrukbare agenter
   → Felles kvalitetskrav og sikkerhetsstandarder

2. Felles kunnskapskilder
   → Lovdata-integrasjon for alle agenter
   → Felles ontologier og datasett

3. Felles infrastruktur
   → Azure Norway East / West
   → Delte APIM-gateways
   → Felles evaluerings-framework

4. Governance
   → Sentralisert godkjenningsprosess
   → Felles retningslinjer for AI-bruk
   → Delt sikkerhets- og personvernevalueringer

Beslutningsrammeverk

Scenario	Anbefaling	Begrunnelse
Intern agent for én avdeling	Sideload + organizational catalog	Rask distribusjon, admin-kontroll
Agent for hele organisasjonen	Organizational catalog + admin-godkjenning	Sentral governance
ISV som bygger for kunder	Microsoft Commercial Marketplace	Bred distribusjon, Partner Center
Offentlig sektor fellesløsning	Organizational catalog + Digdir-koordinering	Gjenbruk på tvers av virksomheter
Multi-agent økosystem internt	Custom plugin registry + Copilot integration	Skalerbar oppdagelse og governance

For arkitekten

• Agenter er apps i Microsoft 365 -- bruk den unified app-modellen for distribusjon, governance og oppdagelse. Ikke bygg parallelle distribusjonskanaler.
• Agent manifest er kontrakten mellom agent og plattform -- definer kapabiliteter, autorisasjonskrav og støttede kanaler eksplisitt. Dette muliggjør automatisert oppdagelse og governance.
• Organizational catalog er startpunktet for intern distribusjon -- publiser via M365 admin center med admin-godkjenning. Escaler til Commercial Marketplace kun for ISV-scenarier.
• Versjonering er kritisk for agentøkosystemer -- bruk semantic versioning, test minor/major-oppgraderinger, og ha rollback-mulighet for alle agent-oppdateringer.
• For norsk offentlig sektor: Design for gjenbruk fra dag 1 -- agenter bygget for én virksomhet bør kunne deles via en felles katalog. Koordiner med Digdir for standarder og felleskomponenter.