Multi-Model AI Agent

Chapter 1 · Foundation

Introduction

CUTEADMOA-5.2 is the second-generation Mixture-of-Agents (MOA) agent. Building on 5.1's five NVIDIA text models, this release adds multimodal image generation, speech-to-text, text-to-speech, and switches from Kimi K2.6 to the more capable DeepSeek V4 Pro.

What's New in 5.2

System Architecture

How the 15 models, 9 providers, and AutoClaw gateway connect.

Complete Model Catalog

Every model registered in agent/models.json and agent/auth-profiles.json.

Text / Reasoning Models

Image Generation Models

Audio Models

Model Comparison Matrix

Quick Start

# Verify the agent is listed
openclaw agents list

# Verify models are registered
cat ~/.openclaw-autoclaw/agents/cuteadmoa-5-2/agent/models.json | python3 -m json.tool | grep '"id"'

# Verify auth profiles
cat ~/.openclaw-autoclaw/agents/cuteadmoa-5-2/agent/auth-profiles.json | python3 -m json.tool | grep '"provider"'

Chapter 2 · Text LLM Integration

Using the Text Models

How to leverage the 7 text LLMs for reasoning, code, research, and conversation.

Choosing a Model for Your Task

AutoClaw Gateway Integration

CUTEADMOA-5.2 is a first-class agent in the AutoClaw gateway.

# openclaw.json — Agent registration
{
  "agents": {
    "list": [
      {
        "id": "cuteadmoa-5-2",
        "name": "CUTEADMOA-5.2",
        "workspace": "~/.openclaw-autoclaw/agents/cuteadmoa-5-2/workspace",
        "model": "zai/zai_auto",
        "subagents": { "allowAgents": ["*"] }
      }
    ]
  }
}

Channel Binding

# Bind WhatsApp to CUTEADMOA-5.2
{
  "bindings": [
    {
      "agentId": "cuteadmoa-5-2",
      "match": {
        "channel": "whatsapp",
        "accountId": "YOUR_ACCOUNT"
      }
    },
    {
      "agentId": "cuteadmoa-5-2",
      "match": {
        "channel": "discord",
        "guildId": "YOUR_GUILD"
      }
    }
  ]
}

Sub-Agent Orchestration

CUTEADMOA-5.2 spawns specialized sub-agents. Each gets an optimal model for its task.

// Spawn an image generation sub-agent
sessions_spawn(
  task: "Generate 3 product mockups in Pixar style",
  taskName: "image_generator",
  label: "Image Designer",
  model: "huggingface-images/Qwen/Qwen-Image"
)

// Spawn a code review sub-agent
sessions_spawn(
  task: "Review PR #42 for security issues",
  taskName: "code_reviewer",
  label: "Code Reviewer",
  model: "custom__857372ba-e3a2-4517-b48f-19db2de71352/qwen3-coder-next"
)

// Spawn a deep research sub-agent
sessions_spawn(
  task: "Research competitor pricing and positioning",
  taskName: "researcher",
  label: "Market Researcher",
  model: "custom__0716bfa4-8828-47d7-8fb4-5e9d977e0139/nvidia/nemotron-3-ultra-550b-a55b"
)

// Spawn a transcription sub-agent
sessions_spawn(
  task: "Transcribe meeting-audio.mp3",
  taskName: "transcriber",
  label: "Audio Transcriber",
  model: "huggingface-audio/openai/whisper-large-v3-turbo"
)

Sub-Agent Model Map

MOA Workflows (Mixture of Agents)

The core power of CUTEADMOA-5.2: run multiple models in parallel or sequence, then aggregate. MOA exploits the diversity bonus — different architectures make uncorrelated errors. Aggregation cancels noise, amplifies signal.

Parallel MOA Pattern

Sequential MOA Pattern

Chapter 3 · Image Generation

Image Generation Pipeline

Three state-of-the-art text-to-image models served via HuggingFace GPU inference. Also accessible through AutoGLM skills for agent-native generation.

HuggingFace GPU Inference

Direct access via the HuggingFace Inference API. All three models share the same token and endpoint.

# Python: Generate with Qwen-Image (recommended default)
from huggingface_hub import InferenceClient

client = InferenceClient(
    provider="auto",
    api_key="hf_xMB…bGTA"  # AutoClaw-managed
)

# Text-to-Image with Qwen-Image
image = client.text_to_image(
    "A cyberpunk city skyline at sunset, neon reflections on wet streets, 8K",
    model="Qwen/Qwen-Image"
)
image.save("cyberpunk.png")

# Photorealistic with FLUX.1-dev
image = client.text_to_image(
    "Professional product photo of a minimalist ceramic vase, natural light",
    model="black-forest-labs/FLUX.1-dev"
)
image.save("product.png")

# Fast concept art with SD 3.5
image = client.text_to_image(
    "Fantasy forest clearing, magical atmosphere, concept art style",
    model="stabilityai/stable-diffusion-3.5-large"
)
image.save("concept.png")

AutoGLM Image Skills

Agent-native image generation — no Python needed. Just ask in chat. Skills automatically select the right model and handle the API call.

autoglm-generate-image

# Just ask naturally in chat
"Generate a Pixar-style family portrait with 4 members"
"Create a modern 3D animation style product render"
"Make a logo for my startup with a mountain and sunrise"

# The skill handles:
# 1. Prompt engineering for best results
# 2. Model selection (falls back to HF if needed)
# 3. Image download and attachment to chat

Batch Generation Scripts

For bulk image generation, use the Python template in the workspace.

#!/usr/bin/env python3
# batch-generate.py — Generate images from a prompt list
import os
from huggingface_hub import InferenceClient

HF_TOKEN = os.environ.get("HF_TOKEN", "hf_xMB…bGTA")
client = InferenceClient(provider="auto", api_key=HF_TOKEN)

prompts = [
    ("A serene Japanese garden at dawn", "garden.png"),
    ("Futuristic Mars colony, domed cities", "mars.png"),
    ("Steampunk airship over Victorian London", "airship.png"),
]

for prompt, filename in prompts:
    print(f"Generating: {prompt}")
    image = client.text_to_image(prompt, model="Qwen/Qwen-Image")
    image.save(filename)
    print(f"  → Saved {filename}")

print("Done!")

Chapter 4 · Audio Processing

Audio Processing Pipeline

Speech-to-text via Whisper Large V3 Turbo and text-to-speech via MMS TTS + SpeechT5. All served through HuggingFace's GPU-accelerated inference.

Speech-to-Text: Whisper Large V3 Turbo

from huggingface_hub import InferenceClient

client = InferenceClient(api_key="hf_xMB…bGTA")

# Transcribe an audio file
result = client.automatic_speech_recognition(
    "meeting-recording.mp3",
    model="openai/whisper-large-v3-turbo"
)
print(result["text"])

# Supported formats: mp3, wav, flac, ogg, m4a, webm
# Languages: 99 languages including EN, ZH, JA, KO, ES, FR, DE, AR, HI
# Accuracy: ~4% WER on English (near-human)

Text-to-Speech: MMS + SpeechT5

MMS TTS (English, simple API)

# Simple English TTS
audio = client.text_to_speech(
    "Hello! I'm CUTEADMOA-5.2, your multi-model AI assistant.",
    model="facebook/mms-tts-eng"
)
with open("intro.wav", "wb") as f:\n    f.write(audio)

SpeechT5 (multilingual, speaker embeddings)

# Multilingual TTS with voice cloning
from transformers import SpeechT5Processor, SpeechT5HifiGan, SpeechT5ForTextToSpeech
import torch

processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")

# Load speaker embedding for voice character
speaker_embeddings = torch.load("speaker_embeddings.pt")

inputs = processor(text="Bonjour le monde!", return_tensors="pt")
speech = model.generate_speech(inputs["input_ids"], speaker_embeddings, vocoder=vocoder)

import soundfile as sf
sf.write("french_output.wav", speech.numpy(), 16000)

End-to-End Audio Pipeline

Transcribe → Process → Generate response → Speak. All on HuggingFace GPU.

#!/usr/bin/env python3
# voice-assistant-pipeline.py
from huggingface_hub import InferenceClient
from openai import OpenAI

hf = InferenceClient(api_key="hf_xMB…bGTA")
nvidia = OpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key="nvapi-…")

# 1. Transcribe
text = hf.automatic_speech_recognition("input.wav", model="openai/whisper-large-v3-turbo")["text"]

# 2. Process with LLM
response = nvidia.chat.completions.create(
    model="nvidia/nemotron-3-ultra-550b-a55b",
    messages=[{"role": "user", "content": text}]
)
reply = response.choices[0].message.content

# 3. Speak response
audio = hf.text_to_speech(reply, model="facebook/mms-tts-eng")
with open("output.wav", "wb") as f:\n    f.write(audio)\n\nprint(f"🎙️ Input: {text[:80]}...")
print(f"🤖 Reply: {reply[:80]}...")
print("🔊 Saved to output.wav")

Chapter 5 · Ecosystem Integration

Claude Code via ACP

Connect CUTEADMOA-5.2 to Claude Code via the Agent Communication Protocol. Use any of the agent's models as the backend for Claude Code coding sessions.

Local stdio Setup

# Start Claude Code in ACP mode
claude-code --acp-stdio

# From OpenClaw agent, spawn Claude Code sub-agent with DeepSeek V4
sessions_spawn(
  runtime: "acp",
  agentId: "claude",
  model: "custom__ffe02b89-8b42-4f23-b4e9-af3a1bd1bd3d/deepseek-ai/deepseek-v4-pro",
  task: "Refactor the authentication module to use JWT with refresh tokens",
  taskName: "auth-refactor"
)

Recommended Claude Code Models

Hermes Evolution System

CUTEADMOA-5.2 supports Hermes self-evolution. The agent watches for repeated patterns, costly mistakes, and user preferences — then drafts structured proposals for human approval.

• Behavior changes → Proposals to AGENTS.md (red lines, conventions)
• Long-term memory → Proposals to MEMORY.md (preferences, lessons)
• Tool config → Proposals to TOOLS.md (API keys, scripts)
• Skill improvements → Proposals to SKILL.md (new features, fixes)
• Every change → Human approves before application

MCP Server Integration

CUTEADMOA-5.2 discovers and uses MCP servers for filesystem access, GitHub operations, database queries, web search, and more — all through a standardized JSON-RPC 2.0 protocol.

# openclaw.json — MCP configuration
{
  "mcp": {
    "enabled": true,
    "gatewayUrl": "http://localhost:3000/mcp",
    "servers": [
      {
        "name": "filesystem",
        "command": "npx",
        "args": ["@modelcontextprotocol/server-filesystem", "/workspace"]
      },
      {
        "name": "github",
        "command": "npx",
        "args": ["@modelcontextprotocol/server-github"],
        "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
      },
      {
        "name": "postgres",
        "command": "npx",
        "args": ["@modelcontextprotocol/server-postgres"],
        "env": { "DATABASE_URL": "${DATABASE_URL}" }
      }
    ],
    "autoDiscover": true
  }
}

Direct API Access

Every provider can be called via OpenAI-compatible API. Provider URLs and keys are in the agent config.

# NVIDIA (Nemotron, DeepSeek, GLM 5.2)
from openai import OpenAI
client = OpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key="nvapi-…")
response = client.chat.completions.create(
    model="deepseek-ai/deepseek-v4-pro",
    messages=[{"role": "user", "content": "Explain async/await in Python"}]
)

# Alibaba Cloud (Qwen3 Coder, Qwen3.5 Omni)
client = OpenAI(
    base_url="https://ws-hflmx206bvspck9t.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    api_key="sk-ws-…"
)
response = client.chat.completions.create(
    model="qwen3-coder-next",
    messages=[{"role": "user", "content": "Write a FastAPI CRUD app"}]
)

# OpenRouter (Claude Opus 4.8)
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="sk-or-…")
response = client.chat.completions.create(
    model="anthropic/claude-opus-4.8-fast",
    messages=[{"role": "user", "content": "Analyze this legal document..."}]
)

Provider Endpoints

Chapter 6 · Deployment

Cloud & Docker Deployment

CUTEADMOA-5.2 runs as an agent inside the AutoClaw gateway. Deploy the gateway, and all registered agents (including 5.2) are available.

# docker-compose.yml
services:
  gateway:
    image: openclaw/gateway:latest
    ports:
      - "8080:8080"
      - "8081:8081"  # ACP WebSocket
    volumes:
      - ./openclaw.json:/config/openclaw.json
      - ./agents/cuteadmoa-5-2:/agents/cuteadmoa-5-2
      - workspace-data:/workspace
    environment:
      - GATEWAY_MODE=production
      - NODE_ENV=production
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "443:443"
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./certs:/etc/nginx/certs
    depends_on: [gateway]

volumes:
  workspace-data:

HuggingFace Space (GPU)

For image/audio models needing dedicated GPU, create a HuggingFace Space. Copy the model configs and set the token as a Space secret. This gives you dedicated GPU inference without rate limits.

# Create a HuggingFace Space with GPU
# 1. Go to https://huggingface.co/new-space
# 2. Choose "Docker" SDK, "T4 small" or "A10G" hardware
# 3. Set HF_TOKEN as a Space secret
# 4. Deploy your inference endpoint

# Space Dockerfile
FROM huggingface/transformers-pytorch-gpu:latest
RUN pip install huggingface_hub Pillow soundfile
COPY app.py /app/app.py
CMD ["python", "/app/app.py"]

# Then update models.json baseUrl to your Space URL
# "baseUrl": "https://your-username-your-space.hf.space"

Security & Token Management

Token Inventory

Best Practices

• Store keys in AutoClaw's encrypted credential store, not plaintext
• Rotate keys every 60–90 days or after any suspected exposure
• Use environment variables (${VAR}) in config, not hardcoded values
• Never share auth-profiles.json as-is — the truncated versions in docs are safe
• Monitor usage in NVIDIA/HF dashboards for anomalies
• HuggingFace token: scoped to inference only, not admin

Appendix A · API Reference

File Structure

~/.openclaw-autoclaw/agents/cuteadmoa-5-2/
├── agent/
│   ├── auth-profiles.json    # All API keys (encrypted references)
│   ├── models.json           # All 15 model definitions
│   └── plugins/
│       └── zai/
│           └── catalog.json   # Z.AI auto-routing catalog
├── workspace/
│   ├── AGENTS.md             # Agent behavior rules
│   ├── SOUL.md               # Personality and tone
│   ├── IDENTITY.md           # Agent identity record
│   ├── USER.md               # User profile
│   ├── TOOLS.md              # Local tool configurations
│   ├── HEARTBEAT.md          # Periodic task checklist
│   └── docs/
│       ├── CUTEADMOA-5.2-Documentation.html
│       └── CUTEADMOA-5.2-Documentation.pdf
└── sessions/
    └── sessions.json          # Session state

Model IDs (full paths)

Appendix B · Version Compatibility Matrix

Appendix C · Troubleshooting

Debug Commands

# Verify agent registration
openclaw agents list | grep cuteadmoa

# Test a model directly
curl -s https://integrate.api.nvidia.com/v1/models \
  -H "Authorization: Bearer nvapi-YOUR_KEY" | python3 -m json.tool

# Test HuggingFace image
python3 -c "
from huggingface_hub import InferenceClient
c = InferenceClient(api_key='hf_xMB…bGTA')
img = c.text_to_image('test red circle', model='Qwen/Qwen-Image')
img.save('/tmp/test.png')
print('OK')
"

# Check gateway logs
tail -f ~/.openclaw-autoclaw/logs/gateway.log | grep -i "cuteadmoa\|error\|acp"