# Agent Ecosystem and Plugin Marketplace Patterns

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

---

## 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

```python
# 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

```json
{
    "$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

```yaml
# 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

```python
# 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

```python
# 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)

```python
# 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 Cosmo

- **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.