Eine Flotte von AI-Agenten

Die nächste Plattform, die Sie bauen werden, ist kein einzelner Agent, sondern ein Schwarm: ein Triage-Agent, der Tickets liest, ein Recherche-Agent, der Kontext abruft, ein Ops-Agent, der Runbooks ausführt, ein Compliance-Agent, der unsichere Aktionen blockiert. Moderne KI-Systeme sind bereits so weit. Was nie existiert hat, ist die Infrastruktur, um diesen Schwarm sicher zu betreiben: bis heute teilte jeder Agent entweder Ihre Master-Credentials, oder Sie bauten ein Berechtigungssystem von Hand.

Das AI Connect SDK gibt jedem Agenten das, was keine Plattform je einem Agenten gegeben hat: die eigene Identität als Benutzer, mit eigenen Connectors, eigenen Credentials, eigenen Ausgaben und eigenem Abschalter, gestützt auf Tausende KI-Verbindungen ab Tag eins. Jedem Agenten die Vereinigung aller Tools zu geben, ist ein Sicherheits- und Kostenrisiko: das Modell verhält sich unvorhersehbar, eine unkontrollierte Schleife kann das Budget aufzehren, und Sie können keine Aktion einem bestimmten Agenten zuordnen. Die übliche Antwort der Industrie ist eine Berechtigungsmatrix, die an ein geteiltes Konto genagelt ist. Das SDK löst das, wie es sonst niemand tut, weil es es so löst wie beim Menschen: jeder Agent ist ein Benutzer. Ein external_id pro Agent, und capabilities() gibt nur das zurück, worauf dieser Agent zugreifen darf. Ein autonomes Programm wird zu einem regierten Bürger Ihrer Plattform. Dieser Satz war für ein Integrationsprodukt nie zuvor wahr. Er ist der strukturelle Unterschied zwischen Agenten, die Ihren Zugang teilen, und Agenten, die ihren besitzen.

Der Nutzen von „Agent = Benutzer“

const capabilities = await vinkius
  .user('alice_123')
  .capabilities({ include: ['github'] });

CapabilitySet (6)
  github__list_issues        read-only
  github__create_issue       POST /repos/{owner}/{repo}/issues
  github__list_pull_requests read-only
  github__search_code        read-only
  ...

1. Geben Sie jedem Agenten eine stabile Identität

Leiten Sie die id aus der Rolle des Agenten und, falls Sie Worker skalieren, aus seiner Instanz ab. Versehen Sie sie mit einem Präfix, damit eine Agenten-id niemals mit einem Menschen oder einer Abteilung kollidiert.

type AgentRole = 'triage' | 'research' | 'ops' | 'compliance';

const agentUserId = (role: AgentRole, instance = 'primary') =>
  `agent-${role}-${instance}`;
// "agent-triage-primary", "agent-ops-worker-07"

2. Legen Sie fest, was jeder Agent verbinden darf

Diese Registry ist Ihre Least-Privilege-Richtlinie. Halten Sie sie deklarativ, damit Sie auf die gesamte Flotte auf einmal schließen können.

// server/fleet.ts
export const AGENTS: Record<AgentRole, { model: string; connectors: string[] }> = {
  triage:     { model: '[MODEL_ID]', connectors: ['zendesk', 'linear'] },
  research:   { model: '[MODEL_ID]', connectors: ['drive', 'confluence', 'search'] },
  ops:        { model: '[MODEL_ID]', connectors: ['pagerduty', 'kubernetes', 'github'] },
  compliance: { model: '[MODEL_ID]', connectors: ['audit-log', 's3'] },
};

3. Stellen Sie einen Agenten bereit

Verbinden Sie beim Deployment die Konten des Agenten. ensure() markiert den Akteur als Agenten, damit Ihr Governance-Dashboard die Flotte von den Menschen herausfiltern kann.

import { vinkius } from './vinkius';
import { AGENTS, type AgentRole, agentUserId } from './fleet';

async function provisionAgent(role: AgentRole, instance = 'primary') {
  const user = vinkius.user(agentUserId(role, instance));
  await user.ensure({ kind: 'agent', role });

  for (const slug of AGENTS[role].connectors) {
    const connector = user.connector(slug);
    await connector.connect();
    // headless Agenten haben keinen Browser-Consent: stellen Sie api_key/token-
    // Credentials über Ihren Secret-Store via connector.credentials.set() bereit
  }
  return user.connectors(); // [{ slug, status }, …]
}

4. Führen Sie die Schleife eines Agenten aus

Jeder Agent lädt seine eigenen, in ihrem Umfang begrenzten Capabilities. Er kann die Tools eines anderen Agenten nicht sehen, weil diese unter einem anderen external_id liegen.

// server/run-agent.ts
import OpenAI from 'openai';
import { vinkius } from './vinkius';
import { toOpenAITools, runOpenAIToolCall } from '@vinkius/connect/openai';
import { AGENTS, type AgentRole, agentUserId } from './fleet';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });

export async function runAgent(role: AgentRole, task: string, instance = 'primary') {
  const user = vinkius.user(agentUserId(role, instance));
  const capabilities = await user.capabilities({ include: AGENTS[role].connectors });

  const messages: object[] = [
    { role: 'system', content: `Sie sind der ${role}-Agent. Erledigen Sie die Aufgabe ausschließlich mit Ihren Tools.` },
    { role: 'user', content: task },
  ];

  for (let step = 0; step < 12; step++) {
    const completion = await openai.chat.completions.create({
      model: AGENTS[role].model,
      messages: messages as never,
      tools: toOpenAITools(capabilities),
    });
    const msg = completion.choices[0].message;
    messages.push(msg as object);
    if (!msg.tool_calls?.length) return msg.content;

    for (const call of msg.tool_calls) {
      const result = await runOpenAIToolCall(capabilities, call);
      messages.push({
        role: 'tool',
        tool_call_id: call.id,
        content: JSON.stringify({ content: result.content, isError: result.isError }),
      });
    }
  }
  return 'Aufgabe gestoppt: Schrittbudget erreicht.';
}

5. Übergeben Sie zwischen Agenten und wahren Sie den Umfang

Ein Triage-Agent eskaliert an den Ops-Agenten, indem er ihn mit einer neuen Aufgabe aufruft. Der Ops-Agent läuft unter seiner eigenen id und verbindet seine eigenen Tools, die Übergabe erweitert niemals das, was einer der beiden Agenten tun kann.

async function orchestrate(ticket: string) {
  const triage = await runAgent('triage', `Klassifizieren und routen: ${ticket}`);

  if (triage?.includes('INFRA')) {
    // der Ops-Agent nutzt pagerduty/kubernetes/github — Tools, die die Triage nie sieht
    return runAgent('ops', `Entschärfen: ${ticket}`);
  }
  return runAgent('research', `Kontext zu ${ticket} sammeln`);
}

6. Der Compliance- / Governor-Agent

Modellieren Sie auch einen Politik-Agenten. Er verbindet schreibgeschützte Tools, prüft die Aktionen eines anderen Agenten und kann einen Konnektor trennen, um einen Agenten zu widerrufen, Governance, ausgedrückt als gewöhnliche SDK-Aufrufe.

async function quarantine(role: AgentRole, instance: string, slug: string) {
  await vinkius.user(agentUserId(role, instance)).connector(slug).disconnect();
}

7. Python oder CrewAI? Überbrücken Sie mit neutralem JSON Schema

Das SDK ist derzeit ausschließlich für TypeScript verfügbar, doch die Capabilities sind portabel. Stellen Sie in einem Python-Stack den Tool-Satz über den neutralen Adapter als Daten bereit, oder rufen Sie die Runtime derselben Verbindung direkt auf.

import { toJSONSchemaTools } from '@vinkius/connect/json-schema';

const definitions = toJSONSchemaTools(await vinkius.user('agent-ops-primary').capabilities());
// übergeben Sie `definitions` an Ihr Python-Agent-Framework; es ruft über eine einzige Route zurück

Interne Mechanik: warum ein einzelner fehlverhaltenender Agent die Flotte nicht kompromittieren kann

Die Isolation, die Sie erben, ist nicht nur organisatorisch, sie wird von der Data Plane durchgesetzt, und das ist der eigentliche Vorteil hinter einer autonomen Flotte.

*Jede Verbindung besitzt ihr eigenes `vk_live_`-Token.* Das Auflisten und Ausführen von Tools geht direkt an die Runtime dieser Verbindung, wo jeder Aufruf über sein eigenes Token gemessen und widerrufbar ist*, niemals über die Application-API. Somit sind die Ausgaben jedes Agenten und die Beendigung jedes Agenten unabhängig von denen aller anderen Agenten, konstruktionsbedingt.

Widerruf schlägt fehlgesichert fehl. Das SDK stellt genau ein Token pro Verbindung bei connect() aus und stellt während der Ausführung niemals implizit ein neues aus. Das bedeutet, dass disconnect() den Zugriff sofort stoppt: Ein Agent mit einem widerrufenen Token kann nicht selbst ein Ersatztoken erhalten. Verwenden Sie es als Notfall-Abschaltung:

// der Governor-Agent hält einen anomalen Worker mit einem einzigen Aufruf an — sofort und endgültig
await vinkius.user('agent-ops-worker-07').connector('pagerduty').disconnect();

Begrenzen Sie jeden Schritt. Ein Agent kann einem langsamen Tool mehr Zeit einräumen als ein Mensch es täte, doch Sie deckeln jeden Aufruf mit timeoutMs (kombiniert mit einem AbortSignal). Eine unkontrollierte Ausführung erhält damit eine harte Frist statt eines unbegrenzten Budgets:

const result = await capabilities
  .findCapability('kubernetes__scale_deployment')!
  .execute(
    { deployment: 'ingress', replicas: 6 },
    { idempotencyKey: `ops:${task.id}:scale`, timeoutMs: 10_000 },
  );

Verfolgen Sie jeden Agenten separat. hooks feuern pro HTTP-Versuch mit einer redigierten requestId, sodass Sie jeden Aufruf, jedes Retry und jeden Fehler einem einzigen external_id zuordnen können, ohne ein eigenes Tracing-System aufzubauen. Credential-Felder und das Pfadsegment vk_live_* werden maskiert, bevor Ihr Hook sie empfängt.

Geben Sie Typen weiter, keinen Freitext. Wenn ein Agent einem anderen Daten weitergibt, ziehen Sie result.structuredContent (das strukturierte Objekt des Konnektors) der Serialisierung von content vor: präziser, token-effizienter und eindeutig.

Produktions-Checkliste

• [ ] Versehen Sie jede Agenten-id mit einem Präfix (agent-…), damit Agenten niemals mit Menschen oder Abteilungen kollidieren.
• [ ] Kapseln Sie Least Privilege in der AGENTS-Registry, ein Agent, eine enge Konnektor-Menge.
• [ ] Geben Sie mutierenden Agenten einen idempotencyKey pro Aufgabe, damit eine wiederholte Schleife nicht doppelt ausführt.
• [ ] Setzen Sie ein hartes Schrittbudget pro Agentenschleife; geben Sie isError an das Modell zurück, statt eine Exception zu werfen.
• [ ] Markieren Sie Akteure mit user.ensure({ kind: 'agent', role }), damit die Governance die Flotte herausfiltern kann.
• [ ] Bauen Sie disconnect() in den Pfad Ihres Governors ein, die Notfall-Abschaltung ist ein Aufruf pro Agent.

Sie betreiben nun eine Flotte, in der jeder Agent exakt die Tools besitzt, die seine Aufgabe benötigt, die Ausgaben jedes Agenten unabhängig sind und ein fehlverhaltenender Agent neutralisiert wird, ohne die anderen zu beeinflussen. Die meisten Teams regieren ihre Agenten mit Policy-Dokumenten und gekreuzten Fingern. Sie regieren Ihre mit einem Identitätssystem, und genau diese Lücke lässt Ihre Flotte über zehn Agenten hinauswachsen, während ihre nicht sicher über zwei hinauswachsen kann.

Nächste Schritte

• Unbeaufsichtigte Automationen und Servicekonten
• Multi-Tenant-Muster
• Framework-Adapter