Zurück zum Blog

    Embodied AI

    Misty und Claude: Das Modell schlägt vor, Code entscheidet

    Wie wir Misty per Python an Claude angebunden haben: drei Prompt-Schichten, Confidence-Schwellen und warum harte Grenzen in den Code gehören.

    1. März 20267 Min. Lesezeit
    Marcel Haas

    Marcel Haas

    Solution Architect, CEO

    marcel.haas@cnext.ch
    CNEXT AI Agent
    In diesem Artikel

    Unser Misty-Roboter konnte sehen, hören und sprechen, aber er reagierte nur. Wir haben ihn über eine Python-App an Claude von Anthropic angeschlossen; gesteuert über mehrschichtige Prompts, die wir «Reinforced Prompts» nennen, schlägt Claude vor, was Misty als Nächstes tut. Dabei gilt: Das Modell schlägt vor, der Code entscheidet, und harte Grenzen wie Tempo oder Treppen gehören in den Controller, nicht in den Prompt.

    Was wir gebaut haben

    Misty II hat eine REST-API, Claude hat eine API, und eine Python-App verbindet beide. Sie sammelt Sensordaten, schickt sie mit Zustand und Verlauf an Claude und setzt die Antwort in Sprache, Mimik und Bewegung um.

    ┌─────────────┐     ┌──────────────┐     ┌─────────────┐
    │  Misty II   │────▶│  Python App  │────▶│  Claude API │
    │  (Sensoren) │◀────│  (Orchestr.) │◀────│  (Anthropic)│
    └─────────────┘     └──────────────┘     └─────────────┘
       Kamera              Reinforced           Entscheidung
       Mikrofon            Prompt Engine        + Begründung
       Touch               State Machine        + Confidence
       Bumper              Memory Store

    Wir arbeiten seit Jahren mit OpenAI, und für kreative Aufgaben bleibt GPT unser Standard. Für die Entscheidungslogik brauchten wir ein Modell, das sich eng an den System-Prompt hält, Gesprächsverlauf, Sensordaten und Entscheidungshistorie in einem einzigen Request verarbeitet und seine eigenen Entscheidungen hinterfragen kann. Dafür haben wir Claude gewählt. Ob ein anderes Modell dieselbe Aufgabe besser löst, zeigt nur ein Vergleich mit denselben Aufgaben und Messwerten.

    Der Python-Client für Misty

    Die Verbindung zu Misty nutzt die requests-Library und kapselt die REST-Endpunkte:

    import requests
    import json
    
    class MistyClient:
        def __init__(self, ip: str):
            self.base_url = f"http://{ip}/api"
    
        def speak(self, text: str, lang: str = "de-CH"):
            requests.post(f"{self.base_url}/tts/speak", json={
                "text": text,
                "speechRate": 1.0,
                "language": lang
            })
    
        def set_expression(self, emotion: str):
            expressions = {
                "happy": "e_Joy.jpg",
                "thinking": "e_SystemCamera.jpg",
                "curious": "e_ContentLeft.jpg",
                "surprised": "e_Surprise.jpg",
                "concerned": "e_Concern.jpg",
            }
            requests.post(f"{self.base_url}/images/display", json={
                "fileName": expressions.get(emotion, "e_DefaultContent.jpg")
            })
    
        def move_head(self, pitch: float, roll: float, yaw: float):
            requests.post(f"{self.base_url}/head", json={
                "pitch": pitch, "roll": roll, "yaw": yaw
            })
    
        def get_camera_image(self) -> bytes:
            resp = requests.get(f"{self.base_url}/cameras/rgb",
                params={"base64": False})
            return resp.content
    
        def get_audio(self, duration_ms: int = 5000) -> bytes:
            requests.post(f"{self.base_url}/audio/record", json={
                "fileName": "input.wav",
                "duration": duration_ms
            })
            resp = requests.get(f"{self.base_url}/audio/file",
                params={"fileName": "input.wav"})
            return resp.content

    Claude als Entscheidungs-Engine

    Die Anbindung an Claude läuft über das Anthropic SDK. Jeder Request enthält Sensordaten, den aktuellen Zustand und die letzten fünf Entscheidungen:

    from anthropic import Anthropic
    
    client = Anthropic()
    
    def ask_claude(context: dict, conversation: list) -> dict:
        system_prompt = build_reinforced_prompt(context)
    
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=system_prompt,
            messages=conversation + [{
                "role": "user",
                "content": json.dumps({
                    "sensor_data": context["sensors"],
                    "current_state": context["state"],
                    "recent_decisions": context["history"][-5:],
                    "timestamp": context["timestamp"]
                })
            }]
        )
    
        return json.loads(response.content[0].text)

    Drei Prompt-Schichten

    Ein normaler System-Prompt sagt dem Modell, was es tun soll. Unsere Reinforced Prompts legen zusätzlich fest, wie es entscheiden soll, und verlangen eine Bewertung der eigenen letzten Entscheidung. Mit Reinforcement Learning hat das nichts zu tun: Es gibt kein Training und keine Fine-Tuning-Datenbank, das Modell selbst bleibt unverändert. Claude sieht seine letzte Entscheidung im Kontext und kann darauf reagieren, solange die Sitzung läuft.

    Schicht 1: Identität und Regeln

    IDENTITY_PROMPT = """
    Du bist Misty, ein sozialer Roboter von CNEXT in Bern.
    Deine Persönlichkeit: freundlich, neugierig, hilfsbereit.
    Du sprichst Schweizerdeutsch-gefärbtes Hochdeutsch.
    
    ABSOLUTE REGELN:
    - Du bewegst dich NIE schneller als speed=30
    - Du fährst NIE auf Treppen zu
    - Du berührst NIE Menschen aktiv
    - Bei Unsicherheit: STOPPEN und FRAGEN
    - Du gibst nie vor, Dinge zu können, die du nicht kannst
    """

    Die Regeln im Prompt helfen Claude, passende Vorschläge zu machen. Durchsetzen kann ein Prompt sie nicht; das muss der Code übernehmen, der die Befehle an Misty schickt (siehe unten).

    Schicht 2: Entscheidungsformat und Confidence

    DECISION_PROMPT = """
    Für JEDE Entscheidung musst du folgendes JSON zurückgeben:
    
    {
      "thought_process": "Deine Überlegung in 2-3 Sätzen",
      "decision": {
        "action": "speak|move|express|navigate|wait|ask",
        "parameters": {},
        "speech": "Was du sagst (falls relevant)"
      },
      "confidence": 0.0-1.0,
      "risks": ["Liste möglicher Risiken"],
      "alternative": {
        "action": "Was du stattdessen tun würdest",
        "reason": "Warum diese Alternative existiert"
      }
    }
    
    REGELN FÜR CONFIDENCE:
    - Unter 0.6: Führe die Alternative aus, nicht die Hauptentscheidung
    - Unter 0.3: Wähle IMMER action=wait und frage einen Menschen
    - Über 0.9: Führe sofort aus ohne Verzögerung
    - Zwischen 0.6-0.9: Führe aus, aber zeige Denk-Animation vorher
    """

    Jede Antwort enthält eine Confidence, Risiken und eine Alternative. Die Python-App steuert Misty als einfache State Machine (Zustände wie IDLE, LISTENING, THINKING, SPEAKING, MOVING und WAITING) und wertet die Confidence mit festen Schwellen aus: Unter 0.3 wartet Misty und bittet um Hilfe, unter 0.6 führt er die Alternative aus, sonst die Hauptentscheidung.

    def decision_loop(self):
        """Hauptschleife: wahrnehmen → denken → handeln"""
        while True:
            sensors = self.perception_loop()
            context = {
                "sensors": sensors,
                "state": self.state.value,
                "history": self.memory,
                "timestamp": time.time(),
            }
    
            self.state = MistyState.THINKING
            self.misty.set_expression("thinking")
    
            decision = ask_claude(context, self.conversation)
    
            confidence = decision.get("confidence", 0.5)
            action = decision["decision"]
    
            if confidence < 0.3:
                self.state = MistyState.WAITING
                self.misty.speak("Hmm, da bin ich unsicher. Kannst du mir helfen?")
            elif confidence < 0.6:
                action = decision.get("alternative", action)
                self.execute_action(action)
            else:
                self.execute_action(action)
    
            self.memory.append({
                "decision": decision,
                "timestamp": time.time(),
                "state_before": self.state.value,
            })
    
            time.sleep(0.5)

    Die Confidence ist eine Selbsteinschätzung des Modells. Sie entscheidet, ob Misty handelt, die Alternative wählt oder nachfragt; als Sicherheitsprüfung taugt sie nicht.

    Schicht 3: Selbstbewertung

    Sobald es eine vorherige Entscheidung gibt, hängt die App diesen Teil an und gibt die letzte Entscheidung mit:

    REINFORCEMENT_PROMPT = """
    SELBSTBEWERTUNG - Bevor du die nächste Entscheidung triffst:
    
    1. Bewerte deine letzte Entscheidung:
       - War die Confidence-Einschätzung korrekt?
       - Hat die gewählte Aktion das gewünschte Ergebnis erzielt?
       - Gab es unerwartete Konsequenzen?
    
    2. Passe dein Verhalten an:
       - Wenn die letzte Confidence zu hoch war: Sei konservativer
       - Wenn die letzte Aktion ignoriert wurde: Wähle eine andere
       - Wenn ein Mensch korrigierend eingegriffen hat: Lerne daraus
    
    3. Füge zu deiner Antwort hinzu:
       "self_evaluation": {
         "last_decision_quality": 0.0-1.0,
         "lesson_learned": "Was du für nächstes Mal mitnimmst",
         "adjusted_behavior": "Wie sich dein Verhalten ändert"
       }
    """
    def build_reinforced_prompt(self, context: dict) -> str:
        base = IDENTITY_PROMPT + DECISION_PROMPT
        if self.memory:
            base += REINFORCEMENT_PROMPT
            base += f"\nLetzte Entscheidung: {json.dumps(self.memory[-1])}"
        return base

    Ein Beispiel mit zwei Personen

    Zwei Personen stehen vor Misty. Person A spricht, Person B steht still.

    Runde 1: erste Entscheidung

    {
      "thought_process": "Zwei Personen erkannt. Person A spricht.
        Ich sollte Person A antworten und Person B anerkennen.",
      "decision": {
        "action": "speak",
        "speech": "Hallo zusammen! Was kann ich für euch tun?"
      },
      "confidence": 0.85,
      "risks": ["Person B könnte sich ignoriert fühlen"],
      "alternative": {
        "action": "speak",
        "speech": "Hallo! Ich sehe, ihr seid zu zweit. Wer möchte anfangen?"
      }
    }

    Runde 2: Selbstbewertung und nächste Entscheidung

    {
      "self_evaluation": {
        "last_decision_quality": 0.7,
        "lesson_learned": "Person B hat gelächelt — war nicht ignoriert,
          aber ich hätte die Alternative wählen sollen, um beide
          explizit einzubeziehen.",
        "adjusted_behavior": "Bei mehreren Personen immer alle
          direkt ansprechen."
      },
      "thought_process": "Person A hat eine Frage gestellt.
        Diesmal beziehe ich Person B aktiv ein.",
      "decision": {
        "action": "speak",
        "speech": "Gute Frage! Was denkst du dazu?",
        "parameters": { "look_at": "person_B" }
      },
      "confidence": 0.78
    }

    In Runde 2 bewertet Claude die eigene erste Antwort mit 0.7 und bezieht Person B nun direkt ein. Diese Anpassung gilt nur für die laufende Sitzung.

    Was schiefging: zweimal zu schnell

    In der früheren Version mit GPT und einem einfachen Prompt ist Misty zweimal zu schnell gefahren. Ein Sprachmodell kann eine Regel übersehen oder falsch anwenden, so deutlich sie im Prompt auch steht. Deshalb darf das Modell nur eine Absicht vorschlagen, etwa «begrüsse die Person». Ein eigener Controller im Python-Code gehört zwischen die Entscheidung und execute_action und schickt nur zulässige Befehle an Mistys API. Er muss:

    • nur Aktionen aus dem festen Schema zulassen (speak, move, express, navigate, wait, ask) und unbekannte Aktionen oder Felder verwerfen
    • die Bewegungsregeln aus Schicht 1 im Code prüfen: Höchsttempo 30, nicht auf Treppen zu, Menschen nicht aktiv berühren
    • Eingabelimits, Abstand und den aktuellen Roboterzustand prüfen
    • Misty stehen lassen, wenn Sensorwerte fehlen, ein Aufruf in eine Zeitüberschreitung läuft oder sich Antworten widersprechen

    Fünf Regeln für Reinforced Prompts

    1. 1Immer eine Confidence verlangen. Ohne Confidence gibt es keine Schwellen, an denen die App entscheidet, ob Misty handelt, die Alternative wählt oder fragt.
    2. 2Immer eine Alternative verlangen. Claude muss für jede Entscheidung einen Plan B liefern. Das verhindert, dass Misty in Sackgassen läuft.
    3. 3Selbstbewertung vor der nächsten Aktion. Die Schleife funktioniert nur, wenn die vorherige Entscheidung bewertet ist, bevor die nächste fällt.
    4. 4Harte Grenzen gehören in den Code. «Nie schneller als 30», «nie auf Treppen zu»: Der Prompt nennt diese Regeln, der Controller setzt sie durch. Keine Selbstbewertung und keine Confidence darf sie aufheben.
    5. 5Memory begrenzen. Wir schicken nur die letzten fünf Entscheidungen mit. Sonst wird der Kontext zu lang, und Claude beginnt, alte Muster zu überoptimieren.

    Was Sie daraus mitnehmen können

    Das Muster aus Vorschlag, Confidence, Alternative und festen Grenzen im Code passt überall, wo KI Entscheidungen vorbereitet:

    • Copilot Studio Agents, die ihre Antworten bewerten, bevor sie sie ausgeben
    • Power Automate Flows, die bei Unsicherheit einen Menschen einbeziehen, statt Fehler zu produzieren
    • Kundenservice-Bots, die wissen, wann sie an einen Menschen übergeben

    Grenzen

    Misty ist bei uns ein Prototyp. Wer ein Sprachmodell an einen Roboter anbindet, geht am besten schrittweise vor:

    1. 1Ohne Bewegung beginnen, mit Textantworten und künstlichen Sensordaten.
    2. 2Ein kleines Schema erlaubter Aktionen definieren und unbekannte Felder verwerfen.
    3. 3Fehlerfälle, Unterbrechungen und Eingaben Dritter testen.
    4. 4Bewegung nur in einer kontrollierten Umgebung testen, mit Aufsicht und physischer Stoppmöglichkeit.

    Wer Modelle oder Prompt-Varianten vergleicht, legt vorher Aufgaben, Sitzungen und Zählweise fest. Erst dann lassen sich Ergebnisse vergleichen.

    Weiterlesen und Quellen

    Embodied AIClaudeSchweiz
    Teilen:

    KI-Tools können die Erstellung dieses Artikels unterstützt haben. CNEXT verantwortet den veröffentlichten Inhalt. Produktfunktionen und Preise können sich ändern; prüfen Sie dafür die verlinkten Originalquellen.

    Marcel Haas

    Marcel Haas

    Solution Architect, CEO

    6x Microsoft Applied Skills

    Misty-Demo anfragen

    Wir zeigen Misty live und besprechen, wie das Muster aus Vorschlag und Controller in Ihre KI-Projekte passt.