AI Engineering|14 Min. Lesezeit

AnewEra: Wie wir eine Plattform gebaut haben, die AI Agents per Prompt erstellt

2025-07-25•Benjamin Amos Wagner

#Coding wird zur Konversation.

Stell dir vor, du sagst:

"Baue einen Agent, der jeden Tag um 8 Uhr die Preise meiner Konkurrenten auf Digitec checkt und mir eine Zusammenfassung per Slack schickt."

Und es passiert. Kein Entwickler nötig. Kein Ticket. Kein Sprint-Planning.

Das ist AnewEra – unsere proprietäre Plattform für AI Agents.

In diesem Artikel zeige ich dir, wie wir sie gebaut haben, welche Technologien dahinterstecken, und warum das die Zukunft von Enterprise-Software ist.

#Der Unterschied: Chatbot vs. Agent

Lass mich einen fundamentalen Unterschied klären, den die meisten Marketing-Abteilungen verwischen:

Ein Chatbot (RAG):

  • Liest deine Dokumente
  • Beantwortet Fragen basierend auf dem Kontext
  • Kann nichts tun ausser Text generieren
  • Ist passiv – er wartet auf deine Frage

Ein Agent:

  • Liest Dokumente UND greift auf Live-Daten zu
  • Schreibt Code, um Probleme zu lösen
  • Führt Aktionen aus (Browser, APIs, Datenbanken)
  • Ist aktiv – er arbeitet autonom nach Zeitplan oder Trigger

Der Chatbot ist ein Bibliothekar. Der Agent ist ein Mitarbeiter.

AnewEra baut Mitarbeiter.

#Kapitel 1: Die Architektur von AnewEra

Hier ist der technische Überblick:

┌──────────────────────────────────────────────────────────────────┐
│                         ANEWERA PLATFORM                          │
├──────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐          │
│  │   PROMPT    │───▶│  ORCHESTRATOR│───▶│  CODE GEN   │          │
│  │   INTERFACE │    │  (LiteLLM)   │    │  (Claude)   │          │
│  └─────────────┘    └─────────────┘    └─────────────┘          │
│         │                  │                  │                   │
│         ▼                  ▼                  ▼                   │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐          │
│  │   CONTEXT   │    │   MODEL     │    │  SANDBOX    │          │
│  │   MANAGER   │    │   ROUTER    │    │  (Daytona)  │          │
│  └─────────────┘    └─────────────┘    └─────────────┘          │
│         │                  │                  │                   │
│         ▼                  ▼                  ▼                   │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐          │
│  │  VECTOR DB  │    │ GPT-4/Claude│    │  EXECUTION  │          │
│  │  (Supabase) │    │ /Gemini     │    │  RESULTS    │          │
│  └─────────────┘    └─────────────┘    └─────────────┘          │
│                                                                   │
└──────────────────────────────────────────────────────────────────┘

#Der Orchestrator: LiteLLM

Das Herz von AnewEra ist LiteLLM – eine Python-Library, die uns erlaubt, zwischen verschiedenen AI-Modellen zu wechseln, ohne Code zu ändern.

from litellm import completion
 
# Dynamischer Model-Switch basierend auf Task
def route_to_model(task_type: str, prompt: str):
    if task_type == "code_generation":
        # Claude 3.5 Sonnet für Code
        model = "anthropic/claude-3-5-sonnet-20241022"
    elif task_type == "reasoning":
        # GPT-4o für komplexe Logik
        model = "gpt-4o"
    elif task_type == "fast_response":
        # Gemini Flash für Speed
        model = "gemini/gemini-1.5-flash"
    else:
        model = "anthropic/claude-3-5-sonnet-20241022"
    
    response = completion(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

Warum ist das wichtig?

  • Claude 3.5 Sonnet ist unser Standard für Code-Generierung (beste Qualität)
  • GPT-4o nutzen wir für Multi-Modal Tasks (Bilder, komplexes Reasoning)
  • Gemini Flash für schnelle, einfache Antworten (kosteneffizient)

Der Kunde merkt davon nichts. Er sieht nur: Es funktioniert.

#Die Sandbox: Daytona

Wenn ein Agent Code schreibt, muss dieser Code irgendwo laufen. Aber wir können nicht einfach User-generierten Code auf unseren Servern ausführen – das wäre ein Sicherheits-Albtraum.

Die Lösung: Daytona Sandboxes.

Daytona erstellt on-demand Docker-Container, die:

  • Komplett isoliert sind (kein Zugriff auf unser System)
  • Automatisch nach der Ausführung zerstört werden
  • Netzwerk-kontrolliert sind (nur erlaubte Domains)
  • Resource-limitiert sind (kein Crypto-Mining möglich)
from daytona_sdk import Daytona
 
# Sandbox für Code-Ausführung erstellen
async def execute_agent_code(code: str, language: str = "python"):
    daytona = Daytona()
    
    # Ephemere Sandbox erstellen
    sandbox = await daytona.create(
        language=language,
        timeout=300,  # Max 5 Minuten
        memory_limit="512mb",
        network_policy="restricted"
    )
    
    try:
        # Code ausführen
        result = await sandbox.run_code(code)
        return {
            "success": True,
            "output": result.stdout,
            "errors": result.stderr
        }
    finally:
        # Sandbox immer zerstören
        await sandbox.destroy()

Das ist Enterprise-Grade Security: Der Agent kann tun, was er will – aber nur in seinem isolierten Käfig.

#Kapitel 2: Browser Automation – Die "Hände" der AI

Ein Agent, der nur Code schreibt, ist limitiert. Die echte Macht kommt, wenn er mit der Welt interagieren kann.

#Web Browsing in Echtzeit

AnewEra-Agents können:

  • Webseiten besuchen und Inhalte extrahieren
  • Formulare ausfüllen und absenden
  • Screenshots machen und analysieren
  • JavaScript-basierte Seiten rendern

Beispiel: Der Competitor-Price-Monitor

from playwright.async_api import async_playwright
from anthropic import Anthropic
 
async def check_competitor_prices():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        
        # Competitor-Seite besuchen
        await page.goto("https://www.digitec.ch/de/s1/product/...")
        
        # Preis extrahieren
        price_element = await page.query_selector('[data-test="price"]')
        price = await price_element.inner_text()
        
        # Screenshot für Analyse
        screenshot = await page.screenshot()
        
        await browser.close()
        
        # AI analysiert den Preis
        client = Anthropic()
        analysis = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            messages=[{
                "role": "user",
                "content": f"Der aktuelle Preis ist {price}. "
                          f"Gestern war er CHF 299. Analysiere die Änderung."
            }]
        )
        
        return {
            "price": price,
            "analysis": analysis.content[0].text,
            "screenshot": screenshot
        }

#Data Analysis On-Demand

Agents können auch Daten analysieren:

  • CSV/Excel-Dateien einlesen
  • SQL-Queries auf Datenbanken ausführen
  • Pandas für Statistiken nutzen
  • Visualisierungen erstellen

Beispiel-Prompt:

"Analysiere unsere Verkaufsdaten der letzten 3 Monate. Finde Trends und erstelle ein Chart."

AnewEra generiert:

import pandas as pd
import matplotlib.pyplot as plt
from supabase import create_client
 
# Daten laden
supabase = create_client(url, key)
data = supabase.table("sales").select("*").gte("date", "2025-04-01").execute()
df = pd.DataFrame(data.data)
 
# Trend-Analyse
df["date"] = pd.to_datetime(df["date"])
daily_sales = df.groupby(df["date"].dt.date)["amount"].sum()
 
# Visualisierung
plt.figure(figsize=(12, 6))
plt.plot(daily_sales.index, daily_sales.values, marker="o")
plt.title("Verkaufstrend Q2 2025")
plt.xlabel("Datum")
plt.ylabel("Umsatz (CHF)")
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig("sales_trend.png")
 
# Insights generieren
trend = "steigend" if daily_sales.iloc[-7:].mean() > daily_sales.iloc[:7].mean() else "fallend"
print(f"Trend: {trend}")
print(f"Durchschnitt: CHF {daily_sales.mean():.2f}")
print(f"Peak: {daily_sales.idxmax()} mit CHF {daily_sales.max():.2f}")

Der Agent schreibt nicht nur den Code – er führt ihn aus und liefert die Ergebnisse.

#Kapitel 3: Embedding Intelligence

Hier wird es für Enterprise-Kunden interessant: Embedded Agents.

Du kannst einen AnewEra-Agent auf deiner eigenen Webseite einbetten – mit einem einfachen JavaScript-Snippet.

#Das Widget

<!-- AnewEra Agent Embed -->
<script>
  (function(w,d,s,o,f,js,fjs){
    w['AnewEraAgent']=o;w[o]=w[o]||function(){(w[o].q=w[o].q||[]).push(arguments)};
    js=d.createElement(s);fjs=d.getElementsByTagName(s)[0];
    js.id=o;js.src=f;js.async=1;fjs.parentNode.insertBefore(js,fjs);
  }(window,document,'script','anewera','https://cdn.anewera.ch/agent.js'));
  
  anewera('init', {
    agentId: 'your-agent-id',
    theme: 'dark',
    position: 'bottom-right',
    greeting: 'Wie kann ich Ihnen helfen?'
  });
</script>

#Was der Embedded Agent kann

Das ist kein normaler Chat-Widget. Der Agent kann:

Aktionen auf deiner Seite ausführen:

  • Formulare vorausfüllen basierend auf Nutzer-Konversation
  • Produkte in den Warenkorb legen
  • Termine buchen (Calendly/Cal.com Integration)
  • Support-Tickets erstellen

Backend-Systeme ansprechen:

  • CRM-Daten abrufen und aktualisieren (HubSpot, Salesforce)
  • Bestellstatus prüfen (Shopify, WooCommerce)
  • Verfügbarkeiten checken (eigene APIs)

Beispiel-Konversation:

Nutzer: "Ich möchte meine Bestellung #12345 stornieren."

Agent: "Ich sehe deine Bestellung #12345 vom 15. Juli. Sie enthält 2x Widget Pro für CHF 299. Die Bestellung ist noch nicht versandt. Soll ich sie jetzt stornieren?"

Nutzer: "Ja, bitte."

Agent: "Erledigt. Die Bestellung wurde storniert. Du erhältst in den nächsten 3-5 Werktagen eine Rückerstattung auf deine Kreditkarte. Kann ich sonst noch helfen?"

Der Agent hat:

  1. Die Bestellung im System gefunden
  2. Den Status geprüft
  3. Die Stornierung durchgeführt
  4. Die Rückerstattung initiiert

Das ist Customer Support, der tatsächlich etwas tut – nicht nur Textbausteine liefert.

#Die Sicherheits-Architektur

Bei Enterprise-Kunden ist Security nicht verhandelbar. Hier ist, wie wir das lösen:

#Daten-Isolation

EbeneMassnahme
Tenant IsolationJeder Kunde hat eigene Datenbank-Schemas
API KeysPro-Agent verschlüsselte Credentials
Sandbox IsolationCode läuft in ephemeren Containern
Network PoliciesAgents können nur erlaubte Domains erreichen
Audit LogsJede Aktion wird protokolliert

#Compliance

  • Hosting in der Schweiz (Exoscale, Infomaniak)
  • DSGVO/nDSG-konform (Datenverarbeitung auf Anfrage löschbar)
  • SOC 2 Type II in Vorbereitung
  • Verschlüsselung at rest und in transit

#Use Cases: Was Kunden bauen

Hier sind echte Beispiele von AnewEra-Agents in Produktion:

#1. Price Intelligence Agent

Kunde: E-Commerce Retailer
Aufgabe: Täglich 500 Konkurrenz-Produkte auf Preisänderungen prüfen
Ergebnis: Automatische Preisanpassungen, 12% Margen-Steigerung

#2. Document Processing Agent

Kunde: Versicherung
Aufgabe: Schadensmeldungen analysieren, kategorisieren, Erstbewertung
Ergebnis: 60% weniger manuelle Bearbeitung im First-Level-Support

#3. Lead Qualification Agent

Kunde: B2B SaaS
Aufgabe: Eingehende Leads recherchieren (LinkedIn, Website), Score vergeben
Ergebnis: Sales-Team fokussiert sich nur noch auf qualifizierte Leads

#4. Compliance Monitor Agent

Kunde: Fintech
Aufgabe: Regulatorische Änderungen (FINMA, SNB) überwachen und zusammenfassen
Ergebnis: Compliance-Team spart 10h/Woche an Recherche

#Der Prompt-to-App Workflow

Lass mich den kompletten Flow zeigen, wenn ein Nutzer einen neuen Agent erstellt:

1. Nutzer-Input:

"Baue einen Agent, der jeden Montag unsere Google Analytics Daten der letzten Woche analysiert und einen Report per Email schickt."

2. AnewEra analysiert:

  • Task-Typ: Scheduled Data Analysis
  • Benötigte Integrationen: Google Analytics API, Email (SMTP/SendGrid)
  • Frequenz: Wöchentlich, Montags
  • Output: Email mit Report

3. Code-Generierung: AnewEra generiert ein Python-Script mit:

  • Google Analytics API Authentication
  • Daten-Extraktion (Pageviews, Sessions, Bounce Rate, Top Pages)
  • Pandas-Analyse und Trend-Berechnung
  • HTML-Email-Template
  • SendGrid Integration

4. Review & Approval: Der Nutzer sieht den generierten Code, kann ihn anpassen oder bestätigen.

5. Deployment:

  • Sandbox wird provisioniert
  • Cron Job wird konfiguriert (jeden Montag 8:00)
  • Credentials werden sicher gespeichert
  • Monitoring wird aktiviert

6. Execution: Jeden Montag läuft der Agent automatisch und der Nutzer erhält seinen Report.

Gesamtzeit: 5 Minuten statt 2 Wochen Entwicklung.

#Fazit: Bau deine eigene Workforce

Die Zukunft der Enterprise-Software ist nicht "kaufen" – sie ist "bauen".

Nicht bauen im Sinne von "Entwickler einstellen". Bauen im Sinne von "beschreiben, was du brauchst".

AnewEra ist der erste Schritt in diese Zukunft:

  • Keine Coding-Kenntnisse nötig (aber möglich für Power-User)
  • Enterprise-Security by Design (Swiss Hosting, Isolation, Compliance)
  • Echte Aktionen, nicht nur Text (Browser, APIs, Datenbanken)

Wenn wir das für uns selbst bauen können, stell dir vor, was wir für dich bauen können.

Interessiert an AnewEra? Wir bieten Pilotprojekte für ausgewählte Enterprise-Kunden. Lass uns besprechen, welchen Agent du als erstes bauen willst.

AnewEra Demo anfragen.

Hat dir dieser Artikel gefallen?

Wir setzen genau diese Technologien für Schweizer Unternehmen ein. Lass uns besprechen, wie das für dich aussehen könnte.

BW

Benjamin Amos Wagner

Digital Nomad / Founder

Baut die Zukunft des Webs mit Next.js, AI Agents und dem Hyperstack. Besessen von Performance, sauberem Code und der Automatisierung langweiliger Aufgaben.