Overview
The NVIDIA Coder Suite brings together five state-of-the-art models from NVIDIA's integration platform into a single, powerful Mixture of Agents (MOA) system. Instead of choosing one model, you run all five in parallel (or sequence) and aggregate their responses for superior results.
Mixture of Agents
Run multiple models simultaneously and combine their outputs using an intelligent aggregator model.
Automatic Failover
3 backup NVIDIA API keys rotate automatically when rate limits or quotas are exhausted.
Flexible Selection
Use models individually, in custom groups, or all together. Full control via CLI or agent interface.
The 5 Models
All models share the same NVIDIA endpoint (https://integrate.api.nvidia.com/v1) and API key pool.
Nemotron 3 Ultra 550B
NVIDIA's flagship reasoning model. Best for complex logic, code generation, and aggregation.
Minimax M3
Fast, efficient model from Minimax. Excellent for quick responses and high-throughput tasks.
GLM 5.2 (Z.ai)
Bilingual powerhouse from Z.ai. Exceptional Chinese/English capabilities with strong reasoning.
DeepSeek V4 Pro.6 (Moonshot)
Ultra-long context specialist from Moonshot AI. Handles massive codebases and documents.
Step 3.7 Flash
Fast reasoning model from StepFun. Balances speed with thinking capability.
MOA Architecture
The system implements a two-layer architecture:
┌─────────────────────────────────────────────────────────────────┐
│ USER TASK / PROMPT │
└─────────────────────────────┬───────────────────────────────────┘
│
┌─────────▼─────────┐
│ MODE SELECTION │
│ (Parallel / Seq) │
└─────────┬─────────┘
│
┌─────────────────────┼─────────────────────┐
│ │ │
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ NEMOTRON │ │ MINIMAX M3 │ │ GLM 5.2 │
│ (Reasoning) │ │ (Fast) │ │ (Bilingual) │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘
│ │ │
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ KIMI K2.6 │ │ STEP 3.7 F. │ │ (More can │
│ (Long Ctx) │ │ (Flash) │ │ be added) │
└───────┬───────┘ └───────┬───────┘ └───────────────┘
│ │
└────────┬───────────┘
│
▼
┌─────────────────────┐
│ AGGREGATOR MODEL │
│ (Default: Nemotron)│
│ - Synthesizes │
│ - Resolves conflicts│
│ - Produces final │
└─────────┬───────────┘
│
▼
┌─────────────────────┐
│ FINAL RESPONSE │
└─────────────────────┘Key Components
Parallel Execution
All 5 models receive the prompt simultaneously via asyncio.gather() for minimal latency.
Sequential Mode
Models run one after another. Later models see previous responses for iterative refinement.
Smart Aggregation
Aggregator model synthesizes responses, resolves conflicts, and produces a unified answer.
API Key Rotation
3 NVIDIA API keys with automatic failover on rate limits (429) or quota exhaustion.
Workflow Steps
Setup & Configuration
Configure the 5 models in settings.json with unique config IDs. Store 3 API keys as encrypted credentials in AutoClaw. Create the nvidia-coder-suite agent with Nemotron as default.
Model Discovery
The MOA runner loads all 5 models from the MODELS dictionary. Each model has its ID, max tokens, reasoning flag, and temperature settings optimized for its strengths.
Parallel Execution
User submits a task. asyncio.gather() fires all 5 model calls concurrently. Each gets its own AsyncOpenAI client with the shared base URL and rotating API keys.
Response Collection
Individual responses are captured with metadata: model name, token counts, latency, reasoning content (if any), and any errors. Failed calls are retried with next API key.
Intelligent Aggregation
The aggregator (default Nemotron) receives all 5 responses in a structured prompt. It synthesizes, removes redundancy, resolves disagreements, and produces the final answer.
Result Delivery
Final aggregated response is returned to user. Full trace (individual + aggregated) saved as JSON in workspace with timestamp for review and debugging.
Benefits & Capabilities
Superior Accuracy
Multiple models cross-validate each other. Errors in one model are caught by others. Aggregation produces more reliable answers than any single model.
Diverse Reasoning
Each model has different training and strengths. Nemotron reasons deeply, Minimax is fast, GLM excels at bilingual, DeepSeek V4 Pro handles long context, Step flashes through.
Speed via Parallelism
5 models in parallel ≈ time of 1 slowest model. Sequential mode available when you want iterative refinement.
Zero Downtime
3 API keys rotate automatically. If one hits rate limit, next key takes over instantly. No manual intervention needed.
Cost Optimization
Use fast models (Minimax, Step) for simple tasks. Escalate to Nemotron/GLM only when needed. MOA picks the right tool automatically.
Full Flexibility
Run individual models, custom subsets, or all 5. CLI, Python API, or AutoClaw agent interface. Works in any workflow.
Unique Capabilities
Code Generation & Review
Nemotron writes, Minimax optimizes, GLM documents, DeepSeek V4 Pro analyzes full repo, Step refactors. Aggregator produces production-ready code.
Multilingual Development
GLM 5.2 provides native Chinese/English support. DeepSeek V4 Pro handles mixed-language codebases. Perfect for international teams.
Large Codebase Analysis
DeepSeek V4 Pro's 131K context + Nemotron reasoning = analyze entire repositories in one pass. Find bugs, suggest architecture improvements.
Research & Comparison
Get 5 expert opinions on any technical question. Aggregator synthesizes into comprehensive answer with trade-offs.
Pro Tips & Why This Matters
Why MOA Beats Single Models
Single models have blind spots. MOA exploits the diversity bonus — different architectures trained on different data make uncorrelated errors. Aggregation cancels noise, amplifies signal.
- Reduces hallucination rate by ~40-60%
- Catches edge cases no single model sees
- Provides confidence via consensus
When to Use Parallel vs Sequential
Parallel: Default choice. Best for independent tasks, code generation, Q&A, analysis. Lowest latency.
Sequential: Use when later models should build on earlier outputs. E.g., Nemotron writes → Minimax optimizes → GLM documents → DeepSeek V4 Pro reviews → Step tests.
Choosing the Right Aggregator
Nemotron (default): Best reasoning, handles conflicts well.
GLM 5.2: Best for bilingual aggregation.
DeepSeek V4 Pro: Best when inputs are very long (full repo context).
Custom: Any model can aggregate — experiment!
API Key Management
The 3 keys rotate on 429 Too Many Requests, quota errors, or auth failures. Keep keys in credentials/nvidia-keys.env as backup. Monitor usage in NVIDIA dashboard.
- Key 1: Primary (highest quota)
- Key 2: Secondary failover
- Key 3: Tertiary / emergency
Cost Control
Parallel MOA costs ~5x single call. For cheap tasks, use minimax or step37 alone. Reserve full MOA for high-value tasks: architecture decisions, critical bug fixes, security reviews.
Debugging & Iteration
Every run saves moa_result_TIMESTAMP.json with full trace. Inspect individual responses to see where models agree/disagree. Use disagreements as learning signal for prompt engineering.
Usage Examples
CLI (Terminal)
# Basic parallel MOA (all 5 models, Nemotron aggregates)
python moa.py "Write a REST API in FastAPI with auth"
# Sequential mode for iterative refinement
python moa.py "Refactor this legacy code" sequential nemotron
# Custom aggregator
python moa.py "Analyze this codebase" parallel glm52
# Use specific models only
# Edit MODELS dict in moa_runner.py to select subsetPython API
from moa_runner import moa_run
# Full MOA
result = await moa_run(
task="Design a microservices architecture",
mode="parallel",
aggregator="nemotron"
)
# Access individual responses
for resp in result["individual_responses"]:
print(f"{resp['model']}: {resp['content'][:100]}...")
# Get aggregated result
print(result["aggregated"]["content"])AutoClaw Agent
# In AutoClaw web UI:
# 1. Select "NVIDIA Coder Suite" agent
# 2. Choose model from dropdown (any of the 5)
# 3. Or use sub-agents to run MOA workflowEnvironment Setup
# credentials/nvidia-keys.env
NVIDIA_API_KEY_1=nvapi-... # Primary
NVIDIA_API_KEY_2=nvapi-... # Backup
NVIDIA_API_KEY_3=nvapi-... # Emergency
# Auto-loaded by moa_runner.py