Super CLI: The First-ever Agent-Native CLI Built for Developing and Optimizing AI Agents

A couple of years ago, command-line interfaces were treated as a 1990's style of application development. However, since the launch of Claude Code, CLI has become the de-facto interface for building software applications. The agentic-coding field is developing at a rapid pace.

For decades, command-line interfaces have powered developer workflows. Tools like Git, Docker, npm, and pip are foundational to how engineers build and deploy software. The industry has changed. We are no longer just building applications. We are building agents - systems that reason, plan, act, and improve over time.

Why Agentic Coding CLIs Fall Short for Agent Development

Despite that shift, many of the tools in common use were designed for the application era, usually referred to as agentic coding. CLIs such as Claude Code, GitHub Copilot, Cursor, Factory CLI, and Gemini CLI have improved how we write code. They do not focus on evaluating or optimizing intelligent behavior. Super CLI was created to address that gap.

Traditional tools are excellent for application development. Building agents is a different discipline. Agent development is about observable behavior, decision-making, tool usage, memory handling, and continuous improvement. Application development is about code correctness, compilation, and deployment.

Applications: Test correctness, refactor functions

Agents: Measure behavior and reasoning, tune prompts and workflows

Traditional CLIs operate in the world of code. Agent developers operate in the world of intelligence orchestration. Super CLI bridges that gap by redefining what a developer CLI can do.

Introducing Super CLI - Built for the Agentic Era

Super CLI is the foundation of agent-native development. We released Super CLI beta last week of October 2025 before Deepa Agent CLI. It is framework-agnostic, evaluation-first, and optimization-core. It is designed to support agent workflows end to end: specify, test, optimize, and deploy.

Supported Frameworks

Super CLI provides a unified workflow across multiple agent ecosystems. Supported frameworks include:

DSPy
OpenAI SDK
CrewAI
Google ADK
Microsoft Agent Framework
DeepAgents

Use a single CLI to build, evaluate, and optimize agents regardless of the underlying framework.

Revolutionary Features

Super CLI is a leap forward in how we build, evaluate, and interact with AI agents. Every feature has been designed with one goal in mind: to make agentic development feel effortless, powerful, and human.

Natural Language Interaction

Forget memorizing complex commands or flags. With Super CLI, you can simply talk to your tools in plain English. Say things like "build a developer agent" or "optimize with GEPA", and the CLI understands your intent. It's command-line magic reimagined for the conversational age - fast, intuitive, and built to think with you.

Built-in MCP Client

Super CLI natively supports the Model Context Protocol (MCP) - a new industry standard that allows seamless connectivity to filesystems, databases, and APIs. Whether your agent needs to pull structured data, read from a local folder, or query an external service, MCP integration makes it simple, secure, and scalable.

Fully Local

Privacy matters. That's why Super CLI runs completely offline with Ollama and MLX, keeping your data where it belongs - on your machine. No background uploads, no hidden telemetry, no cloud lock-in. You get full functionality with 100% privacy guaranteed.

Model Flexibility

Super CLI gives you instant flexibility to switch between local and cloud models. Build and test with Ollama locally, or scale up using OpenAI or Anthropic in the cloud - all with a single command. It's the perfect balance between privacy, performance, and power.

Engaging Animations

Development should be inspiring, not dry. Super CLI includes over fifty beautifully designed, dynamic animations — from "✨ Let me cook…" to subtle progress visuals - making every interaction feel alive. Small details that make big developer experiences.

Built-in Knowledge

Super CLI is a teacher. You can ask it questions directly about the framework — "/ask how does GEPA work?", "/ask what is memory orchestration?" - and get instant, context-aware answers. It's like having the SuperOptiX documentation baked into your terminal.

Secure Authentication

Access marketplace and cloud features with confidence. Super CLI uses GitHub OAuth 2.0 with PKCE, ensuring industry-standard authentication without ever storing passwords. All credentials are kept locally, giving you maximum security with zero compromise.

Multi-Provider Support

Run your agents locally with Ollama or connect to the cloud with OpenAI and Anthropic - and switch between them anytime. Simply type:

Bash

/model set gpt-oss:20b

In seconds, you've changed your entire runtime environment. One CLI, every model, ultimate flexibility.

Getting Started with Super CLI

Installation and launching the CLI are straightforward. Run these commands to install and verify SuperOptiX and Super CLI:

Bash

pip install superoptix
super --version

To open the conversational CLI mode, run:

Bash

super

Conversational mode accepts natural language and slash commands. It can translate intent into the right sequence of commands.

The Agent-Native Development Workflow

Super CLI introduces a workflow tailored to agent lifecycles. You can initialize projects, pull templates, compile agents for different frameworks, run behavioral evaluations, and perform automatic optimization. A typical cycle looks like this:

Bash

# 1. Initialize a new project
super init my_agent_project
cd my_agent_project

# 2. Pull a demo agent or template
super agent pull sentiment_analyzer
super dataset pull sentiment_reviews

# 3. Compile the agent
super agent compile sentiment_analyzer

# 4. Evaluate baseline performance
super agent evaluate sentiment_analyzer

# 5. Automatically optimize behavior with GEPA
super agent optimize sentiment_analyzer

# 6. Re-evaluate the optimized version
super agent evaluate sentiment_analyzer

# 7. Run the agent interactively
super agent run sentiment_analyzer --input "This product is amazing!"

This same flow applies across supported frameworks, allowing you to reuse specifications and workflows without rewriting logic for each provider.

Evaluation-First, Optimization-Core

Super CLI treats evaluation as a first-class concern. You can write behavioral specifications in a RSpec Style BDD-style format or import your dataset. Evaluations run scenarios and produce metrics that reflect behavioral quality rather than just execution success.

When it is time to improve an agent, the built-in optimizer - the Genetic-Pareto Algorithm (GEPA) - explores prompt variations, reasoning strategies, and tool usage patterns to find configurations that improve performance. Trigger GEPA with a single command:

Bash

super agent optimize my_agent --auto medium

GEPA iteratively tests variations and reports progress so you can track improvements and sample efficiency.

Conversational CLI Mode - A CLI That Talks Back

Super CLI provides a hybrid interface that accepts both explicit commands and natural language. Launch conversational mode by running:

Bash

super

Sample interactive prompt:

Bash

✨ Welcome to Super CLI ✨
┌─────────────────────────────────────┐
│  Super CLI                          │
│  The Official SuperOptiX CLI        │
│  Using: ollama (gpt-oss:120b)       │
└─────────────────────────────────────┘
┌────────  Quick Start ─────────────┐
│ /help     Full command reference     │
│ /ask      Ask questions              │
│ /model    List models                │
│ /mcp      MCP server status          │
│ /exit     Exit CLI                   │
└─────────────────────────────────────┘
SuperOptiX › _

In conversational mode you can simply say, for example: "Build a developer agent for code review" or "Optimize this agent with GEPA at medium level". The CLI interprets intent and executes appropriate commands under the hood.

Local-First, Cloud Optional

Super CLI is designed with developer control and privacy in mind. It defaults to local model execution using Ollama or other on-device LLMs. You can choose to connect cloud providers like OpenAI or Anthropic if desired, but local-first operation gives faster iteration, lower cost, and greater control over data.

Natural Language vs Traditional Commands

Super CLI supports both styles. Use conversational prompts for quick iteration, or explicit commands for scripted automation. Examples:

Conversational:

Bash

SuperOptiX › build a developer agent for code review

Under the hood this maps to:

Bash

super spec generate developer_agent --type code_review
super agent compile developer_agent

Both approaches yield the same outcomes - choose the style that suits your workflow.

Watch Super CLI in Action

Conclusion

Super CLI marks the start of an agent-native developer experience. It is designed for people who care about agent reasoning and behavior rather than only code execution. It brings evaluation, optimization, and cross-framework workflows into a single tool. Continuous improvement and observability are first-class features rather than afterthoughts.

If you are building autonomous, adaptive systems, Super CLI provides a unified, repeatable, and measurable approach to development.

Superagentic AI has started the new paradigm of building CLI for developing, evaluating and optimizing AI Agents. Now let's see how many players follow this pattern and come up with new ideas. Meanwhile, we are the pioneers!

Build. Evaluate. Optimize.

Get Started Now

Read Full Documentation

📖 Read detailed version of this blog on your favorite platform

Choose your preferred platform to dive deeper