KI-Agenten ohne ML-Team in SaaS integrieren

Kunden erwarten nützliche KI-Features in den Produkten, die sie bereits verwenden. Die eigentliche Herausforderung ist selten der Aufruf einer KI-Modell-API. Sie liegt im zuverlässigen Betrieb des Features, in der Anbindung an Produktdaten und in der nötigen Transparenz für seine Weiterentwicklung. Wir stellen diese Betriebsinfrastruktur bereit, sodass ein bestehendes Softwareteam KI-Features veröffentlichen kann, ohne zuerst eine KI-Plattform zu bauen.

Ein eigenes ML-Team ist nicht erforderlich, um KI-Agenten in ein Produkt zu integrieren. Dafür braucht das Team eine passende Betriebsplattform.

Warum der klassische Weg zu aufwendig ist

Wenn Teams KI-Agenten in ein Produkt integrieren wollen, stellen sie sich oft ungefähr diesen Ablauf vor:

• 1.Ein Team für Design, Evaluation und Betrieb des Features aufstellen
• 2.KI-Modell-APIs integrieren oder Infrastruktur für selbst gehostete KI-Modelle bereitstellen
• 3.Eine Ausführungsschicht mit der richtigen Skalierung bauen
• 4.Tooling für Prompt Management und Versionierung entwickeln
• 5.Observability, Tracing und Kostenanalyse implementieren
• 6.Alles mit der vorhandenen Produktinfrastruktur verbinden

Der genaue Zeitplan hängt vom Anwendungsfall ab, die Infrastrukturarbeit bleibt jedoch gleich: Das Team verantwortet Laufzeitumgebung und Betrieb, bevor es sich auf das Nutzererlebnis konzentrieren kann. Wir stellen diese Infrastruktur von Anfang an bereit.

KI-Agenten brauchen eine Betriebsplattform

KI-Agenten zu bauen unterscheidet sich nicht grundsätzlich vom Bau anderer Software-Features. Bei vielen API-basierten Anwendungsfällen kann ein erfahrenes Softwareteam starten, ohne KI-Modelle zu trainieren. Benötigt werden:

• •Konfiguration statt Code beschreibt die Aufgabe des Agenten, ohne LLM-Interna nachzubauen
• •Tools in der Sprache des Teams können normale Python-Funktionen statt eigener ML-Pipelines sein
• •Vertraute Workflows ermöglichen Deployments per Git Push statt manueller KI-Modell-Uploads
• •Vorgefertigte Integrationen stellen sofort nutzbare Webhooks, Queues und APIs bereit

Wir haben Connic für diesen Ansatz entwickelt und behandeln das Deployment von KI-Agenten als Aufgabe der Betriebsplattform.

So sieht das in der Praxis aus

Als Beispiel dient eine E-Commerce-Plattform mit einem Support-Agenten, der Fragen zu Bestellungen beantwortet, Erstattungen bearbeitet und komplexe Fälle eskaliert.

Das ist die vollständige Agenten-Konfiguration:

version: "1.0"
name: support-agent
description: "Customer support agent for e-commerce"
model: connic/gpt-5.6-terra
system_prompt: |
  You are a helpful customer support agent for an e-commerce platform.
  You can look up order status, process refunds for eligible orders,
  and escalate complex issues to human agents.

  Always be polite, concise, and helpful. If you're unsure about
  something, say so and offer to escalate to a human.
tools:
  - orders.lookup_order
  - orders.process_refund
  - support.escalate_to_human
  - retrieval_query  # Access company policies

Die Tools sind einfache Python-Funktionen, wie das Team sie bereits schreibt:

import os
import httpx

async def lookup_order(order_id: str) -> dict:
    """Look up order details by order ID."""
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{os.environ['API_URL']}/orders/{order_id}",
            headers={"Authorization": f"Bearer {os.environ['API_KEY']}"}
        )
        return response.json()

async def process_refund(order_id: str, reason: str) -> dict:
    """Process a refund for an eligible order."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{os.environ['API_URL']}/orders/{order_id}/refund",
            json={"reason": reason},
            headers={"Authorization": f"Bearer {os.environ['API_KEY']}"}
        )
        return response.json()

Dieses Setup erfordert kein ML-Training, KI-Modell-Hosting oder eigenes Infrastruktur-Setup. Der Agent läuft auf Managed-Infrastruktur, skaliert mit dem Traffic und ruft bestehende APIs auf.

Integrationsmuster, die funktionieren

Der schnelle Einstieg gelingt, weil sich Agenten einfach mit einem bestehenden Produkt verbinden lassen. Diese Muster werden von Teams am häufigsten eingesetzt:

1. Durch Webhooks ausgelöste Verarbeitung

Das System sendet Events, Agenten verarbeiten sie. Dieses Muster eignet sich für:

• →Eingehende Support-Tickets verarbeiten
• →Formularübermittlungen analysieren
• →Stripe Payment Events verarbeiten

2. Queue-basierte Pipelines

Für hohen Durchsatz mit dauerhafter, wiederholbarer Zustellung lassen sich SQS, Kafka oder andere Message-Queues anbinden. Agenten verarbeiten neue Nachrichten dann direkt.

• →Pipelines zur Anreicherung von Bestellungen
• →Workflows zur Datentransformation
• →Batch-Verarbeitung von Dokumenten

3. Echtzeit-APIs

Für interaktive Features, bei denen Nutzer sofortige Antworten erwarten. WebSocket-Verbindungen streamen Antworten an Chat-Oberflächen.

• →Chat-Assistenten innerhalb der App
• →Suche mit KI-gestützten Antworten
• →Dynamische Generierung von Inhalten

Observability ist Teil des Betriebs

Beim Deployment von KI muss nachvollziehbar bleiben, was ein Agent tut, welche Kosten entstehen und wie eine Entscheidung zustande kommt.

Unsere Plattform liefert diese Transparenz direkt mit. Für jeden Agenten-Run werden erfasst:

• •Vollständige Ausführungs-Traces zeigen jeden LLM-Aufruf, Tool-Aufruf und jedes Zwischenergebnis
• •Der Token-Verbrauch zeigt genau, wie viele Tokens jeder Run verbraucht hat
• •Run History unterstützt Filter nach Status, Zeit und Deployment-Version
• •Fehleranalyse zeigt genau, wo und warum ein Fehler aufgetreten ist

Dafür ist kein zusätzliches Setup nötig, weil die Funktionen von Anfang an Teil der Plattform sind.

Mit Connic schneller zum Produktivbetrieb

Connic verkürzt den Weg in den Produktivbetrieb, indem wiederkehrende Infrastrukturarbeit von der Roadmap verschwindet. Das Team entwickelt den Agenten und das Kundenerlebnis, während Connic die Laufzeitumgebung bereitstellt:

Erste Schritte

Die Einstiegshürde ist bewusst niedrig. Ein Team, das Python schreiben und Git verwenden kann, kann KI-Agenten in ein Produkt integrieren.

$ pip install connic-composer-sdk
$ connic init my-agent
$ cd my-agent
$ connic lint     # Validate configuration
$ connic dev      # Cloud-backed development with hot-reload

Der Quickstart-Leitfaden beschreibt den vollständigen Ablauf. In der Verbindungsdokumentation stehen alle verfügbaren Integrationsoptionen.

Der folgende Überblick zeigt, wie sich mit Connic KI zu einem Produkt hinzufügen lässt.