Autonomous AI Agents für Finance: GPT-4, Claude, AutoGen im Einsatz

Überblick

Autonomous AI Agents = KI-Systeme, die eigenständig Aufgaben lösen (ohne menschliche Anleitung für jeden Schritt).

Unterschied zu einfachen Chatbots:

• ❌ Chatbot: User fragt → LLM antwortet → User führt aus
• ✅ AI Agent: User gibt Ziel → Agent plant + führt aus + prüft Ergebnis (autonom)

Komponenten eines AI Agents:

1. LLM (Large Language Model): GPT-4, Claude, Llama
2. Tools: Funktionen (z.B. Bexio API, SQL-Datenbank, Python-Skript)
3. Memory: Konversationshistorie, Langzeit-Kontext
4. Planning: ReAct-Pattern (Reason + Act)

Dieser Artikel erklärt:

• ✅ Wie AI Agents funktionieren (ReAct-Pattern)
• ✅ GPT-4 Assistants vs. Claude Projects vs. AutoGen
• ✅ Finance Use Cases (Invoice-Automation, Buchhaltungs-Agent, Compliance-Agent)
• ✅ Risiken & Schweizer Compliance

---

1. Grundlagen: Wie funktioniert ein AI Agent?

1.1 ReAct-Pattern (Reason + Act)

ReAct = Reasoning + Acting (entwickelt von Google Research, 2023).

Ablauf:

1. THOUGHT (Denken): Agent analysiert Aufgabe
2. ACTION (Handeln): Agent wählt Tool aus + führt aus
3. OBSERVATION (Beobachten): Agent prüft Ergebnis
4. REPEAT (Wiederholen): Bis Ziel erreicht

Beispiel (Buchhaltungs-Agent):

USER: "Erstelle eine Rechnung für Kunde Müller AG, CHF 1.200"

THOUGHT: Ich muss eine Rechnung in Bexio erstellen. Zuerst prüfe ich,
         ob Kunde "Müller AG" existiert.
ACTION: get_bexio_customer(name="Müller AG")
OBSERVATION: Kunde gefunden, ID: 12345

THOUGHT: Kunde existiert. Jetzt erstelle ich die Rechnung.
ACTION: create_bexio_invoice(customer_id=12345, amount=1200, currency="CHF")
OBSERVATION: Rechnung erfolgreich erstellt, Invoice ID: 67890

THOUGHT: Rechnung erstellt. Aufgabe abgeschlossen.
FINAL ANSWER: ✅ Rechnung #67890 für Müller AG (CHF 1.200) erstellt.

1.2 Tools (Function Calling)

Tools = Funktionen, die Agent ausführen kann.

Beispiel-Tools (Finance-Agent):

• get_bexio_customer(name) - Kunde suchen
• create_bexio_invoice(customer_id, amount) - Rechnung erstellen
• run_sql_query(query) - Datenbank-Abfrage
• send_email(to, subject, body) - E-Mail senden
• calculate(expression) - Mathematik

Function Calling (OpenAI GPT-4):

import openai

# Tools definieren
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_bexio_customer",
            "description": "Sucht Kunde in Bexio nach Name",
            "parameters": {
                "type": "object",
                "properties": {
                    "name": {"type": "string", "description": "Kundenname"}
                },
                "required": ["name"]
            }
        }
    }
]

# Agent-Call
response = openai.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "user", "content": "Erstelle Rechnung für Müller AG, CHF 1.200"}
    ],
    tools=tools,
    tool_choice="auto"  # Agent entscheidet, welches Tool
)

# Agent wählt Tool
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    function_name = tool_call.function.name  # "get_bexio_customer"
    arguments = json.loads(tool_call.function.arguments)  # {"name": "Müller AG"}

    # Tool ausführen (in echtem Code)
    result = get_bexio_customer(arguments["name"])
    print(f"Kunde gefunden: {result}")

---

2. GPT-4 Assistants (OpenAI)

OpenAI Assistants API = Managed AI Agents (OpenAI hostet Agent, verwaltet Memory/Tools).

Features:

• ✅ Code Interpreter: Python-Code ausführen (für Berechnungen, Datenanalyse)
• ✅ Retrieval: Dokumente hochladen (Agent durchsucht Dokumente)
• ✅ Function Calling: Custom Tools (Bexio API, SQL, etc.)
• ✅ Threads: Konversationshistorie (Multi-Turn-Gespräche)

2.1 Finance-Agent erstellen (Python)

Code:

import openai

# Assistant erstellen
assistant = openai.beta.assistants.create(
    name="Finance Assistant",
    instructions="""Du bist ein Buchhaltungs-Assistent für Schweizer KMU.
    Du kannst:
    - Bexio-Rechnungen erstellen
    - SQL-Datenbank abfragen (Finanzdaten)
    - E-Mails senden

    Wichtig:
    - IMMER Schweizer Datenschutz (DSG/nDSG) einhalten
    - IMMER Schweizer MwSt. (8,1%) verwenden
    - Beträge in CHF angeben
    """,
    model="gpt-4-turbo",
    tools=[
        {"type": "code_interpreter"},  # Python ausführen
        {
            "type": "function",
            "function": {
                "name": "create_bexio_invoice",
                "description": "Erstellt Rechnung in Bexio",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "customer_id": {"type": "integer"},
                        "amount": {"type": "number"},
                        "currency": {"type": "string", "enum": ["CHF", "EUR"]}
                    },
                    "required": ["customer_id", "amount"]
                }
            }
        }
    ]
)

print(f"Assistant erstellt: {assistant.id}")

2.2 Thread erstellen (Konversation)

Code:

# Thread erstellen (neue Konversation)
thread = openai.beta.threads.create()

# User-Message hinzufügen
openai.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="Erstelle Rechnung für Kunde ID 12345, CHF 1.200"
)

# Agent ausführen (Run)
run = openai.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id
)

# Warten auf Completion
import time
while run.status in ["queued", "in_progress"]:
    run = openai.beta.threads.runs.retrieve(thread_id=thread.id, run_id=run.id)
    time.sleep(1)

# Antwort abrufen
messages = openai.beta.threads.messages.list(thread_id=thread.id)
print(messages.data[0].content[0].text.value)
# Output: "✅ Rechnung #67890 für Kunde 12345 (CHF 1.200) erstellt."

2.3 Code Interpreter (Beispiel: MwSt.-Berechnung)

User-Frage: "Berechne MwSt. für CHF 10.000 (Schweizer Satz 8,1%)"

Agent-Antwort (mit Python-Code):

# Agent schreibt Python-Code
brutto = 10000
mwst_satz = 0.081
mwst_betrag = brutto * mwst_satz
netto = brutto - mwst_betrag

print(f"Brutto: CHF {brutto:,.2f}")
print(f"MwSt. (8,1%): CHF {mwst_betrag:,.2f}")
print(f"Netto: CHF {netto:,.2f}")

# Output:
# Brutto: CHF 10,000.00
# MwSt. (8,1%): CHF 810.00
# Netto: CHF 9,190.00

Vorteil: Agent kann komplexe Berechnungen selbst durchführen (kein externes Tool erforderlich).

---

3. Claude Projects (Anthropic)

Claude Projects = Long-Context AI Agent (200k Token Kontext = ~500 Seiten Dokumente).

Unterschied zu GPT-4 Assistants:

• ✅ Größerer Kontext: 200k Token (GPT-4: 128k)
• ✅ Besseres Reasoning: Claude Sonnet 4 ist präziser bei komplexen Aufgaben
• ❌ KEIN Code Interpreter: Claude kann keinen Python-Code ausführen
• ⚠️ Function Calling: Verfügbar, aber manuell implementiert (keine Managed API)

3.1 Finance-Agent mit Claude (Python SDK)

Code:

import anthropic

client = anthropic.Anthropic(api_key="your_api_key")

# System Prompt (Agent-Instructions)
system_prompt = """Du bist ein Buchhaltungs-Assistent für Schweizer KMU.

Tools:
- create_bexio_invoice(customer_id, amount, currency)
- get_bexio_customer(name)
- run_sql_query(query)

Wichtig:
- Schweizer MwSt.: 8,1% (Normal), 2,6% (reduziert), 3,8% (Beherbergung)
- Datenschutz: DSG/nDSG compliance
- Beträge immer in CHF
"""

# User-Request
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    system=system_prompt,
    messages=[
        {"role": "user", "content": "Erstelle Rechnung für Müller AG, CHF 1.200"}
    ]
)

print(response.content[0].text)
# Output: "Ich erstelle jetzt eine Rechnung für Müller AG..."

3.2 Long-Context Use Case: Jahresabschluss-Analyse

Szenario: Unternehmen hat 500 Seiten Buchhaltungsdaten (camt.053 XML, Kontoauszüge).

Aufgabe: "Analysiere alle Transaktionen 2025, finde Anomalien"

Claude Projects:

1. Dokumente hochladen: 500 Seiten XML (im Project)
2. Agent-Prompt: "Analysiere alle Transaktionen, finde: (1) Duplikate, (2) Ungewöhnlich hohe Beträge, (3) Falsche MwSt.-Sätze"
3. Agent-Antwort (nach Analyse von 200k Token):

   ✅ Analyse abgeschlossen (12.500 Transaktionen):
   
   🚨 Anomalien gefunden:
   1. Duplikate: 3 Zahlungen (ID: 1234, 1235, 1236)
      - Gleicher Betrag (CHF 5.000) an gleichen Empfänger
      - Gleicher Tag (15.08.2025)
      - Empfehlung: Prüfen, evtl. Rückbuchung
   
   2. Ungewöhnlich hohe Beträge: 2 Transaktionen
      - CHF 250.000 (20.12.2025, Lieferant XYZ GmbH)
      - CHF 180.000 (05.09.2025, Consultant ABC Ltd)
      - Empfehlung: Verträge prüfen
   
   3. Falsche MwSt.-Sätze: 5 Rechnungen
      - Rechnung #1001: 7,7% (sollte 8,1% sein, ab 2024)
      - ...
   

Vorteil: Kein Chunking erforderlich (gesamte Buchhaltung auf einmal analysiert).

---

4. AutoGen (Microsoft Multi-Agent Framework)

AutoGen = Framework für Multi-Agent-Systeme (mehrere Agents arbeiten zusammen).

Use Case: Finance-Team (3 Agents):

1. Analyst-Agent: Analysiert Daten (SQL-Queries)
2. Compliance-Agent: Prüft Schweizer Regulierung (DSG, FINMA)
3. Executor-Agent: Führt Aktionen aus (Bexio API)

4.1 Multi-Agent-Workflow (Beispiel)

Aufgabe: "Erstelle Quartalsabschluss Q4 2025, inkl. FINMA-Meldung"

AutoGen-Workflow:

from autogen import AssistantAgent, UserProxyAgent

# Agent 1: Analyst
analyst = AssistantAgent(
    name="Analyst",
    system_message="Du analysierst Finanzdaten (SQL-Datenbank)",
    llm_config={"model": "gpt-4-turbo"}
)

# Agent 2: Compliance
compliance = AssistantAgent(
    name="Compliance",
    system_message="Du prüfst FINMA-Compliance",
    llm_config={"model": "gpt-4-turbo"}
)

# Agent 3: Executor
executor = AssistantAgent(
    name="Executor",
    system_message="Du führst Aktionen aus (FINMA-Meldung XML erstellen)",
    llm_config={"model": "gpt-4-turbo"}
)

# User Proxy (startet Workflow)
user_proxy = UserProxyAgent(
    name="User",
    human_input_mode="NEVER",  # Vollautomatisch
    code_execution_config={"use_docker": False}
)

# Workflow starten
user_proxy.initiate_chat(
    analyst,
    message="Erstelle Quartalsabschluss Q4 2025, inkl. FINMA-Meldung"
)

# Agent-Kommunikation (autonom):
# Analyst → Compliance: "Hier sind die Q4-Daten (Gewinn, Verlust, Risiken)"
# Compliance → Analyst: "Daten sind FINMA-konform, aber Risiko X muss gemeldet werden"
# Compliance → Executor: "Erstelle FINMA XML mit Risiko X"
# Executor → User: "✅ FINMA-Meldung erstellt (finma_q4_2025.xml)"

Vorteil: Spezialisierte Agents (jeder Agent hat eigenes Fachgebiet).

---

5. Finance Use Cases

Use Case 1: Invoice-Automation-Agent

Aufgabe: E-Mails checken → Rechnungen extrahieren → Bexio-Rechnung erstellen

Agent-Workflow:

1. TOOL: gmail_read_emails(unread=True)
   OBSERVATION: 5 neue E-Mails, 2 enthalten Anhänge (PDF)

2. TOOL: ocr_extract_invoice(pdf_path="email_1_attachment.pdf")
   OBSERVATION: Rechnung gefunden (Betrag: CHF 1.200, Lieferant: ABC GmbH)

3. TOOL: get_bexio_supplier(name="ABC GmbH")
   OBSERVATION: Lieferant gefunden, ID: 789

4. TOOL: create_bexio_expense(supplier_id=789, amount=1200)
   OBSERVATION: Kreditor-Rechnung erstellt, ID: 456

5. FINAL: ✅ Rechnung von ABC GmbH (CHF 1.200) in Bexio erfasst

ROI: 100 Rechnungen/Monat × 5 Min = 8,3h/Monat gespart.

Use Case 2: Compliance-Agent (FINMA-Meldung)

Aufgabe: Prüfe Transaktionen auf FINMA-Meldepflicht (> CHF 100k)

Agent-Workflow:

1. TOOL: run_sql_query("SELECT * FROM transactions WHERE amount > 100000")
   OBSERVATION: 3 Transaktionen gefunden

2. THOUGHT: FINMA-Rundschreiben 2024/1 besagt: Transaktionen > CHF 100k
            an Nicht-EU-Länder müssen gemeldet werden.

3. TOOL: check_country(transaction_id=1)
   OBSERVATION: Empfängerland: Panama (Hochrisiko-Land)

4. TOOL: create_finma_report(transaction_id=1, reason="Hochrisiko-Land")
   OBSERVATION: FINMA-Meldung erstellt (XML)

5. FINAL: ✅ FINMA-Meldung für Transaktion #1 (Panama, CHF 150k) erstellt

Compliance-Vorteil: Kein FINMA-Verstoß (automatische Meldung).

Use Case 3: Predictive Cash Flow Agent

Aufgabe: "Prognostiziere Liquidität für nächste 3 Monate"

Agent-Workflow:

1. TOOL: run_sql_query("SELECT * FROM invoices WHERE status = 'open'")
   OBSERVATION: Offene Forderungen: CHF 50.000

2. TOOL: run_sql_query("SELECT * FROM bills WHERE status = 'open'")
   OBSERVATION: Offene Verbindlichkeiten: CHF 30.000

3. TOOL: code_interpreter (Python):
   # Historische Daten (letzten 12 Monate)
   import pandas as pd
   df = pd.read_sql("SELECT date, cash_flow FROM ledger WHERE date > '2025-01-01'", conn)

   # Linear Regression (einfaches Modell)
   from sklearn.linear_model import LinearRegression
   model = LinearRegression()
   X = df.index.values.reshape(-1, 1)
   y = df['cash_flow'].values
   model.fit(X, y)

   # Prognose nächste 3 Monate
   future_months = [[13], [14], [15]]
   forecast = model.predict(future_months)

   print(f"Prognose: {forecast}")  # [CHF 25k, CHF 22k, CHF 20k]

4. FINAL: 📊 Liquiditätsprognose (nächste 3 Monate):
          - Monat 1: CHF 25.000
          - Monat 2: CHF 22.000
          - Monat 3: CHF 20.000
          ⚠️ Warnung: Liquidität sinkt, ggf. Kreditlinie sichern

---

6. Risiken & Schweizer Compliance

6.1 Halluzinationen (LLM-Fehler)

Problem: AI Agent erfindet Daten (z.B. "Rechnung #99999 existiert nicht, aber Agent sagt 'Rechnung gefunden'").

Lösung:

• ✅ Validation: Nach jedem Tool-Call prüfen (z.B. if invoice_id not in database: raise Error)
• ✅ Human-in-the-Loop: Kritische Aktionen (> CHF 10k) müssen von Mensch bestätigt werden
• ✅ Logging: Alle Agent-Aktionen loggen (Audit Trail)

6.2 DSG/nDSG Compliance

Problem: AI Agent verarbeitet personenbezogene Daten (Namen, Adressen, Finanzdaten).

Anforderungen (DSG/nDSG):

• ✅ Verschlüsselung: Alle Daten at-rest + in-transit (TLS 1.3, AES-256)
• ✅ Datenminimierung: Agent darf nur notwendige Daten abrufen
• ✅ Zweckbindung: Daten nur für definierten Zweck nutzen (z.B. "Rechnung erstellen", nicht "Marketing")
• ✅ Löschung: Daten nach Verarbeitung löschen (kein permanentes Speichern im LLM-Kontext)

OpenAI/Anthropic: Beide garantieren KEINE Speicherung von API-Daten für Training (Enterprise-Pläne).

6.3 FINMA-Aufsicht (für Finanzinstitute)

Wenn Ihr KMU FINMA-reguliert ist (Bank, Vermögensverwalter):

• ✅ Outsourcing-Regelung (FINMA-RS 2018/3): AI Agent = Outsourcing → FINMA muss informiert werden
• ✅ Operational Risk: AI-Fehler MUSS im Risikomanagement erfasst werden
• ✅ Audit Trail: Alle AI-Entscheidungen MÜSSEN nachvollziehbar sein (Logging)

---

7. Kosten-Vergleich (AI Agents)

Szenario: 1.000 Invoice-Automation-Tasks/Monat

GPT-4 Turbo (OpenAI)

Model: gpt-4-turbo-2024-04-09

Kosten:

• Input: USD 0,01 / 1k Token
• Output: USD 0,03 / 1k Token

Pro Task (durchschnittlich 5k Input + 2k Output):

• Input: 5k × USD 0,01 / 1k = USD 0,05
• Output: 2k × USD 0,03 / 1k = USD 0,06
• TOTAL: USD 0,11 ≈ CHF 0,10

1.000 Tasks/Monat: CHF 100

Claude Sonnet 4 (Anthropic)

Model: claude-sonnet-4-20250514

Kosten:

• Input: USD 0,003 / 1k Token
• Output: USD 0,015 / 1k Token

Pro Task:

• Input: 5k × USD 0,003 / 1k = USD 0,015
• Output: 2k × USD 0,015 / 1k = USD 0,03
• TOTAL: USD 0,045 ≈ CHF 0,04

1.000 Tasks/Monat: CHF 40

Fazit: Claude ist 60% günstiger (bei vergleichbarer Qualität).

---

8. ROI-Kalkulation (AI Agent vs. Mensch)

Szenario: Invoice-Automation (100 Rechnungen/Monat)

Manuell (OHNE AI Agent)

Aufwand:

• 100 Rechnungen × 5 Min = 500 Min/Monat = 8,3h/Monat
• Kosten: 8,3h × CHF 85/h = CHF 706/Monat

AI Agent (MIT Automation)

Kosten:

• Claude Sonnet 4: 100 Tasks × CHF 0,04 = CHF 4/Monat
• Entwicklung (einmalig, 40h × CHF 150/h): CHF 6.000
• Jahr 1: CHF 6.000 + CHF 48 = CHF 6.048
• Ab Jahr 2: CHF 48/Monat

Einsparung:

• Jahr 1: CHF 8.472 (12 × CHF 706) - CHF 6.048 = CHF 2.424
• Jahr 2: CHF 8.472 - CHF 48 = CHF 8.424 (17.550% ROI) 🚀

---

Nächste Schritte

Option 1: AI Agent-Development (CHF 6.000, 40h)

• Wir entwickeln Custom AI Agent für Ihre Anforderung
• Inklusive: Tool-Integration (Bexio, SQL, E-Mail), Testing, Deployment

👉 Service buchen

Option 2: Kostenlose Beratung (60 Min)

• Wir analysieren Ihre Prozesse, identifizieren AI-Agent-Potenzial
• ROI-Berechnung: Lohnt sich AI Agent für Ihr KMU?

👉 Termin buchen

---

Veröffentlicht: 01. Februar 2026 Autor: SwissFinanceAI Team Kategorie: AI Innovation