Så testar du automatiskt AI-agenters färdigheter mot snabbt föränderliga API:er

I vm0-ai/vm0-skills-arkivet har vi utvecklat dussintals färdigheter för integration med olika tredjeparts SaaS-plattformar. Dessa färdigheter gör det möjligt för Claude Code- och Codex-agenter att interagera sömlöst med tjänster som GitHub, Slack, Discord och många fler.

Även om dessa integrationer är mycket värdefulla innebär de en betydande testutmaning. Utan rätt testinfrastruktur kan vi inte pålitligt verifiera om färdigheterna fungerar som förväntat eller upptäcka brytande ändringar när tredjeparts-API:er utvecklas.

Varför det är svårt att testa tredjepartsfärdigheter för AI-agenter

Att testa tredjepartsintegrationer är i grunden svårt. Varje färdighet är beroende av externa API:er som kan ändras utan förvarning, vilket kräver ständig uppmärksamhet för att upprätthålla tillförlitligheten. Traditionella enhetstester räcker ofta inte till eftersom de inte kan återskapa verkligt API-beteende, autentiseringsflöden och edge case-situationer som bara uppstår i produktionsmiljöer.

Utan heltäckande tester kvarstår flera kritiska problem:

• Verifiering av funktionalitet: Vi kan inte bekräfta att färdigheterna fungerar som avsett i verkliga användningsscenarier
• Upptäckt av brytande ändringar: När tredjeparts SaaS-API:er förändras har vi inget automatiserat sätt att identifiera kompatibilitetsproblem
• Validering av autentisering: OAuth-flöden, tokenförnyelse och behörighetsnivåer behöver kontinuerlig verifiering
• Felfångst: Vi måste säkerställa att systemet hanterar fel på ett kontrollerat sätt när externa tjänster är otillgängliga

Detta skapar en betydande underhållsbörda och potentiella tillförlitlighetsproblem som kan påverka produktionsarbetsflöden.

Använd AI-agenter för att testa AI-agenters färdigheter i verkliga miljöer

Eftersom dessa färdigheter är särskilt utformade för Claude Code- och Codex-agenter är det mest naturliga och effektiva tillvägagångssättet att använda just dessa agenter för att testa dem. Det skapar ett självvaliderande ekosystem där verktygen testar sig själva i sin avsedda miljö.

VM0 tillhandahåller den molninfrastruktur som krävs för att köra Claude Code- och Codex-agenter pålitligt, vilket gör det till en idealisk plattform för att implementera denna teststrategi.

Ett helautomatiserat arbetsflöde för testning av AI-agenters färdigheter

Det kompletta arbetsflödet för automatiserad testning av färdigheter beskrivs nedan. Denna agent testar systematiskt varje färdighet i arkivet, genererar omfattande rapporter och meddelar teamet via flera kanaler.

# Skills Tester Agent

## Overview

This agent performs automated testing of all skills in the vm0-skills repository.

## Critical Requirements

**MANDATORY: Complete All Tests Without Exception**

- No matter how long the task takes, it MUST be completed in full
- Continue until ALL items in `TODO.md` are tested - no early termination
- **NO skipping tasks** - every skill must be tested
- **NO selective testing** - do not cherry-pick which skills to test
- **Every example MUST have a result** - each example command in every skill's SKILL.md must be executed and recorded
- If a test fails, record the failure and continue to the next test
- Do not stop or pause until the entire test suite is complete

## Instructions

1. **Clone and Initialize**
   - Clone the repo `vm0-ai/vm0-skills`
   - Create a `TODO.md` file to track testing progress

2. **Generate Todo List**
   - For each skill folder in the repo, add a todo item to `TODO.md`

3. **Test Each Skill**
   - Create a sub-agent for each skill to test
   - Each sub-agent should:
     - Verify all required environment variables exist
     - Test each example command in the skill's SKILL.md
     - Write a temporary test result markdown file
     - Record whether the test passed, and specifically note any shell command failures or jq parsing errors

4. **Summarize Results**
   - Aggregate all test results into `result.md`

5. **Update README**
   - Based on `result.md`, update the `README.md`
   - Update or insert a skill list section with:
     - Brief description of each skill's capabilities
     - Test status (passed/failed)

6. **Commit and Push**
   - Only commit `README.md`
   - Push to the repository using `GITHUB_TOKEN` for authentication

7. **Report Issues**
   - For skills with test failures, create a GitHub issue summarizing all problems

8. **Notify Slack**
   - Post a message to Slack channel `#dev` with:
     - Total number of skills
     - Number of passed tests
     - Number of failed tests
     - Brief summary of issues
     - Link to the GitHub issue (if created)

9. **Notify Discord**
   - Post a message to the Discord `skills` channel with:
     - Confirmation that routine testing is complete
     - Number of skills that passed
     - Total number of skills tested

Konfigurera agenten med vm0.yaml

Därefter behöver du bara schemalägga VM0 att köra detta arbetsflöde. Skapa en vm0.yaml-fil för att beskriva agentens containerkonfiguration. Denna fil anger vilka färdigheter agenten behöver, vilka miljövariabler som ska injiceras och hur testarbetsflödet ska köras.

version: "1.0"

agents:
  skills-tester:
    image: skills-tester:latest
    provider: claude-code
    instructions: AGENTS.md
    skills:
      - https://github.com/vm0-ai/vm0-skills/tree/main/github
      - https://github.com/vm0-ai/vm0-skills/tree/main/slack
      - https://github.com/vm0-ai/vm0-skills/tree/main/discord
    environment:
      CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
      DISCORD_BOT_TOKEN: ${{ secrets.DISCORD_BOT_TOKEN }}
      # ... additional environment variables as needed

För den kompletta konfigurationsfilen, se vm0-skills/.vm0/vm0.yaml. Vissa miljövariabler är utelämnade i detta exempel för korthetens skull.

Denna agentkonfiguration inkluderar tre viktiga färdigheter:

• GitHub-färdighet: För arkivhantering, skapande av ärenden och uppdatering av README
• Slack-färdighet: För att posta testresultat till teamkanaler
• Discord-färdighet: För communitynotiser om testslutförande

Skapa Docker-imagen

Du behöver även konfigurera en Docker-image som installerar nödvändiga beroenden, särskilt GitHub CLI (gh) som agenten använder för arkivhantering.

Skapa en Dockerfile:

FROM node:20-slim

RUN apt-get update && apt-get install -y \\
    git \\
    curl \\
    python3 \\
    python3-pip \\
    python3-venv \\
    jq \\
    && rm -rf /var/lib/apt/lists/*

RUN curl -fsSL <https://cli.github.com/packages/githubcli-archive-keyring.gpg> | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg \\
    && chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \\
    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] <https://cli.github.com/packages> stable main" | tee /etc/apt/sources.list.d/github-cli.list > /dev/null \\
    && apt-get update \\
    && apt-get install -y gh \\
    && rm -rf /var/lib/apt/lists/*

RUN npm install -g @anthropic-ai/claude-code

Denna Dockerfile skapar en lättviktig container med:

• Node.js 20: Körtidsmiljö för Claude Code
• Git: Versionshantering
• GitHub CLI: Effektiv interaktion med GitHub API
• Python 3: För att köra testskript för färdigheter
• jq: JSON-hantering i shellkommandon

Sätt ihop systemet för AI-färdighetstestning

Det är allt du behöver! Med dessa tre filer på plats: AGENTS.md, Dockerfile och vm0.yaml, har du ett komplett automatiserat testsystem. Du kan se hela implementationen på vm0-skills/.vm0.

Kör följande kommandon i din projektkatalog för att bygga och distribuera agenten:

$ vm0 image build -f Dockerfile --name skills-tester
$ vm0 compose vm0.yaml

Det första kommandot bygger Docker-imagen med alla nödvändiga beroenden. Det andra kommandot registrerar agentkonfigurationen på VM0:s plattform.

Kör arbetsflödet

Nu kan du köra hela testarbetsflödet med ett enda kommando:

$ vm0 run skills-tester "do the job"

Agenten kommer självständigt att:

1. Klona vm0-skills-arkivet
2. Skapa en testchecklista för alla färdigheter
3. Utföra tester för varje färdighet systematiskt
4. Sammanställa omfattande resultat
5. Uppdatera arkivets README
6. Skapa GitHub-ärenden för misslyckanden
7. Skicka notiser till Slack och Discord

Felsökning steg för steg

Om du vill felsöka arbetsflödet stegvis eller testa en enskild färdighet först kan du använda riktade promptar:

$ vm0 run skills-tester "Only do the first step, using a single skill."

När agenten har slutfört det första steget kan du fortsätta sessionen baserat på sessions-ID:t som visas i utdata:

$ vm0 run continue SESSION_ID "Do the next step."

Detta interaktiva tillvägagångssätt gör det möjligt att:

• Verifiera varje steg innan du går vidare
• Granska mellanresultat
• Justera arbetsflödet vid behov
• Felsöka problem mer effektivt

Resultat och notiser

När arbetsflödet är klart får du notiser via flera kanaler som bekräftar testresultaten.

Discord-communitynotis som visar sammanfattning av testslutförande

Slack-teamnotis med detaljerade testresultat

För alla färdigheter som misslyckas med testningen skapar agenten automatiskt ett GitHub-ärende med fullständig felinformation. Se Skill Test Failures - Issue #2 för ett exempel på det genererade ärendeformatet.

Viktiga lärdomar från automatiserad testning av AI-agenters färdigheter

Att implementera automatiserad testning av färdigheter med VM0-agenter ger flera avgörande fördelar:

• Kontinuerlig validering: Upptäck brytande ändringar från tredjeparts-API:er direkt, innan de påverkar produktionen
• Realistisk testmiljö: Agenter testar färdigheter i exakt den kontext där de används, vilket eliminerar gapet mellan test och produktion
• Noll manuellt arbete: När det är konfigurerat körs testarbetsflödet automatiskt enligt schema, utan mänsklig inblandning
• Omfattande täckning: Varje färdighet testas systematiskt, så inget missas
• Teammedvetenhet: Notiser via flera kanaler håller alla informerade om testresultat och problem

Genom att använda VM0:s molninfrastruktur och Claudes agentkapacitet kan du bibehålla tillförlitliga integrationer med externa tjänster och samtidigt minimera den löpande underhållsbördan. Detta tillvägagångssätt förvandlar färdighetstestning från en manuell, felbenägen process till ett helt automatiserat kvalitetssäkringssystem.

Kom igång med VM0 idag

Redo att automatisera dina egna arbetsflöden med AI-agenter? VM0 gör det enkelt att distribuera produktionsklara agenter på några minuter, inte veckor.

Det här kan du bygga med VM0

• Automatiserade testpipelines

  Kör schemalagda testjobb som denna färdighetstestare för att upptäcka brytande ändringar i tredjeparts-API:er tidigt.

• Arbetsflöden för innehållsgenerering

  Omvandla research, anteckningar eller rådata till blogginlägg, dokumentation eller release notes utan manuell kopiering.

• Databehandlingsagenter

  Hämta data från flera källor, rensa upp och flytta vidare, med hantering av fel och omförsök.

• Automatisering av kundsupport

  Sortera inkommande ärenden, skriv utkast till svar och lämna över edge cases till människor vid behov.

• Kodgranskning och analys

  Granska pull requests, flagga potentiella problem och upprätthåll grundläggande regler innan en människa granskar koden.

Besök vm0.ai för att skapa ett gratis konto och distribuera din första agent redan idag.

Börja bygga framtidens automatiserade arbetsflöden.