SuperOptiX vs Agent Bricks: DSPy-Powered Titans of Agentic AI

Shashikant Jagtap

We’re entering a golden era for agent frameworks — where building powerful, production-grade AI agents no longer requires months of custom engineering. There are many frameworks available in the market which are based on prompt tinkering techniques. DSPy is the only framework which allows developers to focus on programming rather prompting. The first DSPy powered Agentic AI framework was released by DataBricks called Agent Bricks this year in June. Then on July 17th Superagentic AI released the SuperOptix which follows TDD/BDD for Agentic AI. Two DSPy-powered frameworks have recently emerged as frontrunners in this space: SuperOptiX by Superagentic AI, and Agent Bricks by Databricks. Both share the same underlying DNA — they leverage DSPy, the compositional optimization framework — yet their philosophies could not be more different.

Agent Bricks was unveiled on June, 2025, as part of Databricks’s push into Agentic AI infrastructure. It’s designed for speed, simplicity, and automation — focusing on letting enterprise users spin up agents with minimal effort. SuperOptix , meanwhile, is a new  project that puts engineers firmly in the driver’s seat — offering full control over agent specification, evaluation, orchestration, memory, and observability.

Let’s explore how these two frameworks compare — not just in features, but in philosophy, use case, and approach to building intelligent systems.

Philosophical Foundations: Engineering Discipline vs Automated Magic

Agent Bricks adopts a “no-code, auto-magic” approach. The idea is simple: you describe your task in natural language, and the system builds, optimizes, and evaluates your agent behind the scenes. It’s ideal for product teams and domain experts who don’t want to touch code.

  • Designed for business outcomes: Users focus on what the agent should do — not how it works internally.
  • Auto-evaluation and optimization: It generates evals and scoring criteria automatically.
  • Integrated deeply with MLflow and Databricks: Making it seamless for enterprises already on that stack.

SuperOptiX, in contrast, was built for developers and AI engineers who want full transparency and control. It takes a “spec-first” approach where agents are defined declaratively using a DSL called SuperSpec, tested with BDD-style scenarios, and orchestrated in pipelines.

  • Engineering-centric: Designed for those who care about reproducibility, observability, and version control.
  • Explicit specifications: Everything — from personas to tasks and scenarios — is declared in YAML and evaluated deterministically.
  • Built-in CI/CD readiness: With quality gates, test harnesses, and support for real-time metrics.

Task Definition: Natural Language vs Structured DSL

Agent Bricks lets you define task for an agent in the natural language probably like this:

Build an agent that can analyze customer feedback and generate actionable insights for product improvement

This approach is fantastic for fast prototyping — but it comes with downsides.

  • ✅ Super intuitive: Anyone can define tasks — no coding required which means task definition is arbitrary.
  • ✅ Great for product managers and analysts: It abstracts away all complexity.
  • ❌ Lacks structure: Task definition aren’t version-controlled, and agent logic is not explicit.
  • ❌ Context engineering is weak: You can’t easily build modular or testable or repeatable workflows.

SuperOptiX uses a structured YAML DSL with SuperSpec:

apiVersion: agent/v1
kind: AgentSpec
metadata:
  name: "customer_feedback_analyzer"
  tier: "genies"
  version: "1.0.0"
spec:
  persona:
    role: "Customer Feedback Analyst"
    goal: "Analyze customer feedback and generate actionable insights"
  tasks:
    - name: "analyze_feedback"
      instruction: "Analyze customer feedback for sentiment, themes, and actionable insights"
      inputs: [{"name": "feedback", "type": "str"}]
      outputs: [{"name": "analysis", "type": "str"}]
  feature_specifications:
    scenarios:
      - name: "positive_feedback_analysis"
        input: "I love the new interface design!"
        expected: "Positive sentiment detected with specific UI feedback"

 

  • ✅ Highly maintainable: DSL specs are version-controlled and testable.
  • ✅ Enables advanced testing: You can write BDD-style scenarios before deploying.
  • ❌ Steeper learning curve: Requires YAML knowledge and engineering mindset and most importantly need to learn SuperSpec DSL

Evaluation: Black Box vs Transparent

Agent Bricks features automatic evaluation . It generates its own benchmarks and evaluation functions — giving users instant feedback on performance. It’s great for fast iteration, but lacks transparency.

  • ✅ No Human Control: It handles test case  or evals creation for you which is great but you are not in the driving seat, you might get evals that you no longer needed.
  • ✅ Auto-generates metrics: Using judge agents and synthetic data.
  • ❌ You can’t control the metrics: Developers don’t define what “good” means unless auto generated evals are manually reviewed.
  • ❌ Evaluation logic is opaque: You rely on Agent Bricks’ internal models.

SuperOptiX provides full control via CLI and DSL

# Run BDD-style evaluation
super agent evaluate customer_analyzer --verbose

# Output:
#  Functional accuracy: 95%
#  Behavioral compliance: 92%
#  Safety checks: All passed
#  BDD scenarios passed: 80%

 

  • ✅ Full control over test cases: You define input/output expectations in the SuperSpec.
  • ✅ Output in multiple formats: JSON, JUnit, tabular — ready for pipelines.
  • ✅ Real-time CLI feedback: Perfect for CI/CD workflows.
  • ❌ Requires setup: You must write and maintain your tests.

Optimization: TAO vs Manual Strategy

Agent Bricks leverages TAO (Test-time Adaptive Optimization), a cutting-edge technique that uses unlabeled data to optimize agents post-deployment. It adjusts behavior in real-time — much like reinforcement learning — without human-in-the-loop labeling.

  • ✅ Impressive autonomy: Agents self-improve during usage.
  • ✅ Works with usage data only: No need for labeled examples.
  • ❌ Lack of visibility: Users don’t see what’s changing or why.
  • ❌ Risk of overfitting: Especially in domains with edge-case variability.

SuperOptiX offers multiple explicit strategies:

# Manual optimization
super agent optimize customer_analyzer 
super agent evaluate customer_analyzer
  • ✅ Transparent: You pick the optimizer: BootstrapFewShot, KNNFewShot, LabeledFewShot, etc.
  • ✅ Framework-agnostic: Integrates with any LLM or model backend.
  • ❌ More effort: You must choose and tune optimization paths.
  • ❌ Needs DSPy Optimizer Knowledge: You must choose and tune optimization paths. You also need to know names of DSPy Optimizers and what they do

Multi-Agent Orchestration: Basic vs Advanced

Agent Bricks claims to support multi-agent orchestration, but little documentation exists, and coordination patterns are limited.

  • ✅ Users don’t need to know the technical details of Muti-agent systems if it’s done automatically.
  • ✅ Came from best researchers
  • ❌ No orchestration spec language other than not documented (or I am not aware)
  • ❌ Limited parallelism or context chaining

SuperOptiX supports detailed orchestration using Kubernetes style YAML:

orchestra:
  execution:
    strategy: "sequential"
    max_parallel_tasks: 3
agents:
  - feedback_collector
  - sentiment_analyzer
  - insight_generator
tasks:
  - name: collect_feedback
    agent: feedback_collector
  - name: analyze_sentiment
    agent: sentiment_analyzer
    context: ["collect_feedback"]
  - name: generate_insights
    agent: insight_generator
    context: ["analyze_sentiment"]

 

  • ✅ Sequential and parallel patterns supported
  • ✅ Pipeline-style coordination
  • ✅ Shared memory and broadcast supported
  • ❌ Too technical for the non DevOps non tech people to setup
  • ❌ Need to know SuperOptiX YAML specs whats supported and whats not
  • ❌ Tightly couple with SuperOptiX framework with no user visibility and early stage

Memory & Knowledge: Minimal vs Multi-layered

Agent Bricks offers basic vector memory, but lacks detail around long-term storage, session memory, or episodic learning.

SuperOptiX includes a full memory stack:

  • Short-term memory: Temporary context window
  • Episodic memory: Task-level or session memory
  • Long-term memory: Vector-backed persistent memory
  • Semantic memory: Searchable embeddings for prior knowledge

Backends include ChromaDB, Qdrant, LanceDB, Milvus, and Pinecone.

Final Verdict: Choose the Titan That Matches Your Mindset

This post comes with whatever public information that available for Agent Bricks but they might have even stronger features for DataBricks customers. Agent Bricks is the clear winner for teams that want fast deployment and automated tuning without engineering overhead. It’s ideal if you’re deeply integrated with Databricks, want rapid iteration, and trust automation to handle the messy details.

SuperOptiX is a 1 day old baby but has immense potential, it’s for those who treat AI agents as systems — who want to test, optimize, and ship with confidence. It’s for developers who want version control, orchestration, memory control, and long-term maintainability. No need to lock yourself in the DataBricks, ML

Finally, DataBricks is big company with huge resources while Superagentic AI is just 2 month old startup so there is no head to comparison at this stage so Agent Bricks might be right choice for most of you if you are in DataBricks world. Also  Note that, this work came from some cool researcher and actual DSPy contributors so it must be great! However, thing to note that there is option now if you want to do Context Engineering and let the SuperOptiX handle DSPy Agent Engineering.

This is just comparison done with my personal knowledge of Agent Bricks but DataBricks people can correct me If something is misinterpreted in this post.