Discover how SuperOptiX builds tailored agents and multi-agent systems for software engineering teams. Learn how each use case and dataset produces unique agent specifications optimized for your specific needs.
git --version)Set PYTHONUTF8=1 environment variable:
set PYTHONUTF8=1Choose your preferred installation method
This guide uses DSPy for GEPA optimization and orchestration.
1. Install uv:
curl -LsSf https://astral.sh/uv/install.sh | sh
2. Install SuperOptiX with DSPy:
uv pip install -U superoptix[frameworks-dspy]
3. Verify installation:
super --help
Follow these 10 steps to build your AI development team (using traditional CLI commands)
Steps 4-6 (evaluate and optimize) are optional. For the fastest quick start, go from Step 3 directly to Step 7.
Create your software engineering project structure.
super init swe cd swe
Created structure: agents/, evals/, guardrails/, knowledge/, memory/, optimizers/, orchestras/, pipelines/, protocols/, servers/, teams/, tools/
Download a pre-built developer agent from the marketplace.
super agent pull developer
Downloaded: agents/developer_playbook.yaml with complete SuperSpec DSL configuration
Generate executable Python code from the SuperSpec DSL.
super agent compile developer
What happens: Your agent specification is compiled into executable code with built-in evaluation scenarios, ready to run in pipelines/developer_pipeline.py
Optional baseline check against RSpec-style BDD scenarios before optimization.
super agent evaluate developer
💡 Don't worry about initial scores!
Agents start with generic prompts. Optimization in Step 5 will significantly improve performance!
Optional performance pass: GEPA automatically improves agent instructions through evolutionary optimization.
super agent optimize developer --auto medium
⚡ What happens during optimization:
Optional: load the optimized agent and measure improvement.
super agent evaluate developer
🏆 Significant performance improvements!
GEPA optimization dramatically increases agent accuracy and reliability
Test your optimized agent on a real-world task.
super agent run developer --goal "Implement a user registration API endpoint with email validation"
Optional: if you want to use cloud providers like Google (Gemini)
export GOOGLE_API_KEY="your-google-api-key"
super agent compile developer --framework dspy --cloud --provider google-genai --model gemini-2.5-flash
super agent run developer --framework dspy --cloud --provider google-genai --model gemini-2.5-flash --goal "Implement a user registration API endpoint with email validation"
Pull QA Engineer and DevOps Engineer to complete the team.
# Pull QA engineer super agent pull qa_engineer # Pull DevOps engineer super agent pull devops_engineer # Compile both agents super agent compile qa_engineer super agent compile devops_engineer
💡 Pro Tip: You can optimize these agents too!
For this quick start, we'll use them as-is for the orchestra. But feel free to run optimize + evaluate on them for even better results!
✅ You now have a complete 3-agent team ready for orchestration!
The Kubernetes moment! Orchestrate your agents like a container platform.
1. Create the Orchestra:
super orchestra create sdlc
Auto-detects your agents and creates orchestras/sdlc_orchestra.yaml
2. List Available Orchestras:
super orchestra list
3. Run the Orchestra:
super orchestra run sdlc --goal "Build a complete web application for a task management system with user authentication, CRUD operations, and real-time notifications. Include comprehensive testing and deployment configuration."
🎭 What Just Happened (The Magic!):
Developer analyzed the goal and provided implementation reasoning
DevOps Engineer created CI/CD pipeline based on developer's output
QA Engineer created comprehensive test plan based on both outputs
The orchestra automatically:
📋 Generated Artifacts:
🎉 The Kubernetes Moment!
SuperOptiX just orchestrated your agents like a container orchestration platform:
Inspect agent traces and monitor performance.
View traces:
super observe traces developer
SuperOptiX is built on cutting-edge technologies like DSPy and powered by GEPA (Genetic-Pareto Algorithm), the world's first universal agent optimizer. These advanced frameworks enable SuperOptiX to deliver production-ready, optimized agents across all major frameworks.
SuperOptiX leverages DSPy for structured prompting, signatures, and advanced optimization techniques. DSPy's systematic approach to prompt engineering ensures your agents are built on proven, research-backed foundations.
Learn more about DSPyGEPA (Genetic-Pareto Algorithm) is the universal optimizer that works across all 7 frameworks. It automatically improves your agents' performance with minimal training data, delivering proven results in production environments.
Explore GEPASuperOptiX is built on advanced optimization concepts and DSPy philosophy. If you're new to these technologies, we strongly recommend booking a demo first, as the platform can be overwhelming without prior knowledge of optimization concepts and DSPy's systematic approach to prompt engineering.
Describe what you need your agent to do. Provide your use case requirements and define the agent's responsibilities, just like writing a job description for a software engineer.
If possible, provide a few samples of your data as gold examples. The more samples you can provide, the better SuperOptiX can tailor the SuperSpec to your specific patterns and requirements.
Note: This step is optional. If creating a full dataset is too much work, SuperOptiX can work with just your agent job description.
SuperOptiX analyzes your job description and sample data, then delivers a complete Agent Specification with SuperSpec. This specification becomes your source of truth and can be compiled against any agent framework (DSPy, OpenAI SDK, CrewAI, etc.).
Your agent specification stays as the source of truth, while technologies become modular and pluggable as needed. This architecture is future-proof for the fast-paced changes in AI. Switch frameworks, protocols, or optimizers without rewriting your agent specification.
Each use case and dataset is unique, so SuperOptiX will generate different SuperSpecs for agents built for different purposes. A customer support agent will have different specifications than a code review agent, even if they use similar frameworks. This customization ensures optimal performance for your specific business needs.
SuperOptiX comes with DSPy and GEPA by default, giving you the most powerful optimization out of the box.
But you're not locked in! Use the exact same workflow with any of 7+ frameworks:
Stanford research framework with powerful optimization capabilities
Best for:
Quick start:
pip install -U superoptix[frameworks-dspy]
super agent pull sentiment_analyzer
Simple agents with OpenAI's powerful models
Best for:
Quick start:
pip install -U superoptix[frameworks-openai]
super agent pull assistant_openai
Multi-agent collaboration
Best for:
Install:
pip install -U superoptix[frameworks-crewai]
Pull agent:
super agent pull researcher_crew
⚠️ Cannot be installed with DSPy (json-repair conflict)
Gemini 2.0 native
Best for:
Install:
pip install -U superoptix[frameworks-google]
Pull agent:
super agent pull assistant_adk
Setup API key:
export GOOGLE_API_KEY=your-google-api-keyEnterprise Azure
Best for:
Install:
pip install -U superoptix[frameworks-microsoft]
Pull agent:
super agent pull assistant_microsoft
Complex planning
Best for:
Install:
pip install -U superoptix[frameworks-deepagents]
Pull agent:
super agent pull research_agent_deepagents
Type-safe agents with MCP
Best for:
Install:
pip install -U superoptix[frameworks-pydantic-ai]
Pull agent:
super agent pull developer
Compile with framework:
super agent compile developer --framework pydantic-ai
Same command works on ALL 7 frameworks! This is the revolutionary power of SuperOptiX.
# Works on DSPy, OpenAI SDK, CrewAI, Google ADK, Microsoft, DeepAgents, Pydantic AI! super agent optimize <agent_name> --auto medium # Examples: super agent optimize sentiment_analyzer --auto medium # DSPy super agent optimize assistant_openai --auto medium # OpenAI super agent optimize researcher_crew --auto medium # CrewAI super agent optimize assistant_adk --auto medium # Google ADK super agent optimize assistant_microsoft --auto medium # Microsoft super agent optimize research_agent_deepagents --auto medium # DeepAgents super agent optimize developer --framework pydantic-ai --auto medium # Pydantic AI
Quick iteration, prototyping (2-3 iterations)
Most use cases (5 iterations)
Critical production agents (10+ iterations)
✅ Framework-Agnostic Optimization
No framework-specific tricks. No vendor lock-in. Just pure, portable optimization across your entire agentic stack.
# 1. Initialize super init openai_project cd openai_project # 2. Pull OpenAI agent super agent pull assistant_openai # 3. Compile super agent compile assistant_openai # 4. Baseline evaluation super agent evaluate assistant_openai # Result: Check initial performance # 5. Optimize with GEPA super agent optimize assistant_openai --auto medium # GEPA optimizes agent # 6. Re-evaluate super agent evaluate assistant_openai # Result: 100% pass rate! # 7. Run super agent run assistant_openai
Designed for software engineering teams, SuperOptiX transforms your agent requirements into production-ready specifications that work across any framework.
For a single agent, you define the agent's job description (what it should do) and optionally provide sample data. SuperOptiX analyzes both and generates a SuperSpec, your agent specification.
For multi-agent systems (like a software development team), you define each agent's role and how they coordinate. SuperOptiX generates orchestrated specifications for the entire system.
Software Engineering Team Use Case
Each agent receives a different SuperSpec because each has a different role, different sample data patterns, and different requirements. The Developer agent's SuperSpec will differ significantly from the QA agent's SuperSpec, even though they're part of the same system. This is the power of SuperOptiX: truly tailored agents for each use case.
The SuperSpec generated by SuperOptiX becomes your source of truth. This specification stays constant while technologies become modular and pluggable.
Compile your SuperSpec to DSPy today, OpenAI SDK tomorrow, CrewAI next week. Your specification stays the same.
Switch between MCP, A2A, or custom protocols without changing your agent specification.
As AI evolves, swap optimizers, frameworks, or tools without rewriting your agent definition.
You've Explored the Future of Agent Development!
You just experienced a framework-agnostic agent platform with optimization at its core
Developer, QA, DevOps working together
Automatic performance improvements
Production-grade validation
DSPy, OpenAI, CrewAI, Google, Microsoft, DeepAgents, Pydantic AI
Production-ready artifacts generated
🔓 Zero Lock-In
Switch frameworks anytime. Your agents, optimizations, and tests stay portable.
⚡ Optimization-First
GEPA works universally across all frameworks. Same command, consistent improvements.
🎯 Production-Ready
Built-in evaluation, orchestration, and monitoring from day one.
First platform that works universally across all major agent frameworks
GEPA optimizer built-in from the start, not an afterthought
Orchestra features for seamless agent coordination
Add spec.datasets to your playbook for larger training and evaluation input sets. Keep a smallfeature_specifications section for targeted edge-case checks.
# agents/developer_playbook.yaml spec: datasets: - name: training_data source: ./data/sentiment_train.csv format: csv mapping: input: text output: label input_field_name: text output_field_name: sentiment limit: 1000 shuffle: true feature_specifications: - name: edge_cases description: Keep a few critical scenario checks scenarios: - Given: "the input is empty" When: "the agent processes the request" Then: "it asks for more details"
super agent dataset validate developer
super agent dataset preview developer --limit 5
super agent dataset info developer