Flezi AgentBox

Core Concepts

Understand the fundamental concepts behind Flezi AgentBox: agents, pipelines, marketplace, templates, and more

Core Concepts

This page explains the key concepts and terminology used throughout the Flezi AgentBox platform. Understanding these concepts will help you get the most out of every feature.

Agents

An agent is the core unit of work on Flezi AgentBox. An agent is an AI-powered program that takes input, processes it through a defined pipeline, and produces output.

Agent Anatomy

Every agent consists of:

  • Metadata — Name, description, category, tags, and version
  • Knowledge Base — Context documents and reference data the agent uses
  • Pipeline — The processing logic defined as a DAG (Directed Acyclic Graph)
  • Configuration — LLM provider, model selection, temperature, and other parameters
  • Persona — Optional personality and behavior guidelines

Agent Lifecycle

Agents go through several stages:

Draft → Published → Active → Deprecated → Sunset
  • Draft: Being built in the Builder Lab, not visible to others
  • Published: Available on the marketplace for discovery and execution
  • Active: The current recommended version
  • Deprecated: Replaced by a newer version, still runnable
  • Sunset: Permanently retired, no longer executable

Agent Types

Flezi AgentBox supports several agent categories:

| Category | Description | Example | |----------|-------------|---------| | Code Assistant | Programming help and code generation | Code Review Agent | | Data Analysis | Data processing and visualization | CSV Analyzer | | Content Creation | Text generation and editing | Blog Writer | | Customer Support | Conversational support bots | FAQ Bot | | DevOps | CI/CD and infrastructure automation | Deploy Pipeline | | Research | Information gathering and synthesis | Market Research Agent |

Pipelines

A pipeline defines how an agent processes information. Pipelines are built using a visual DAG editor in the Builder Lab's Logic phase.

Pipeline Components

Nodes

Individual processing steps. Each node represents one operation: an LLM call, a data transformation, a conditional branch, or a service integration.

Edges

Connections between nodes that define execution order and data flow. Data flows from source nodes to target nodes along edges.

Validation

Before publishing, the pipeline is validated to ensure:

  • No cycles exist (it's a true DAG)
  • All nodes are reachable from the start node
  • Required inputs are connected
  • Output nodes produce the expected format

Execution Modes

Pipelines support two execution patterns:

  • Sequential: Nodes execute one after another, each receiving the previous node's output
  • Parallel: Independent nodes execute simultaneously for faster processing
yaml
# Sequential execution
A → B → C → D
 
# Parallel execution
A → [B, C] → D
# B and C run in parallel, D waits for both to complete

Agent Pipelines (Composition)

You can chain multiple published agents together into an Agent Pipeline:

  • Each agent in the pipeline receives the previous agent's output
  • Inter-agent data transformation rules handle format conversion
  • Published pipelines appear in the marketplace alongside individual agents

Agent Pipelines are different from internal agent pipelines. An internal pipeline defines the logic within a single agent, while an Agent Pipeline chains multiple agents together.

Marketplace

The marketplace is where agents are published, discovered, and acquired.

Discovery

Users find agents through:

  • Search — Full-text search across agent names, descriptions, and tags
  • Categories — Browse by type (Code Assistant, Data Analysis, etc.)
  • Filters — Filter by runtime engine, access level, rating, and price
  • Collections — Curated bundles of related agents
  • Trending — Agents with rising popularity based on the Impact Score

Reviews and Ratings

Community-driven quality signals:

  • Star Ratings — 1-5 star reviews with text feedback
  • Review Voting — Mark reviews as helpful or unhelpful
  • Rating Summary — Average score with star distribution
  • Review Moderation — Admin oversight for inappropriate content

Creator Storefronts

Each creator has a public profile showcasing:

  • Published agents with sort options (stars, runs, newest)
  • Pinned featured agents
  • Activity feed (publishes, updates, milestones)
  • Creator statistics (total agents, stars, executions)
  • Collections they've curated

Economics

Flezi AgentBox supports a creator economy:

  • Execution Pricing — Creators set per-execution prices
  • Revenue Share — Platform takes a percentage, creator receives the rest
  • Payout Dashboard — Track earnings, view transaction history
  • Free Tier — Agents can be offered for free

Templates

Templates are pre-built agent configurations that users can start from in the Builder Lab.

Using Templates

Browse templates

When starting a new agent in the Builder Lab, choose Start from Template to see available templates.

Select and customize

Pick a template that matches your use case. The template pre-fills the Discovery, Logic, and Output phases with sensible defaults.

Modify as needed

Templates are starting points, not constraints. Customize any part of the agent to fit your specific needs.

Community Templates

Users can submit their agent configurations as community templates:

  • Published agents can be converted to templates
  • Templates go through an approval process
  • Popular templates are featured in the Builder Lab

Execution Sandbox

The execution sandbox is a secure, isolated environment for running agents.

Key Features

  • Real-time Streaming — Output appears as it's generated via SSE (Server-Sent Events)
  • Container Isolation — Each execution runs in its own Docker container
  • Environment Profiles — Save and switch between different execution configurations
  • Execution History — View past runs with full input/output logs
  • Keyboard Shortcuts — Power user controls for efficient interaction

Security

Execution environments are:

  • Isolated — Each run gets its own container with no access to other users' data
  • Time-limited — Executions have configurable timeout limits
  • Resource-bounded — CPU and memory limits prevent runaway processes
  • Logged — All executions are recorded for auditing

MCP IDE Integration

The Model Context Protocol (MCP) allows you to invoke Flezi AgentBox agents directly from your IDE.

Supported IDEs

  • Visual Studio Code
  • Cursor
  • Claude Code (CLI)

How It Works

  1. Configure the Flezi AgentBox MCP server in your IDE settings
  2. Authenticate with your API key
  3. Discover available agents from the IDE command palette
  4. Invoke agents with input from your editor context
  5. Receive streamed results directly in your IDE

The MCP integration is especially powerful for code-related agents — run code review, generate documentation, or analyze security issues without leaving your editor.

Collections

Collections are curated bundles of agents organized by theme or use case.

  • Create Collections — Group your favorite agents by topic
  • Public/Private — Share collections with others or keep them personal
  • Collaborative — Multiple users can contribute to shared collections

Versioning

Flezi AgentBox uses semantic versioning for agents:

  • Major (v2.0.0) — Breaking changes to input/output format
  • Minor (v1.1.0) — New features, backward compatible
  • Patch (v1.0.1) — Bug fixes and improvements

Each version includes:

  • Changelog — Description of what changed
  • Rollback — One-click revert to any previous version
  • Notifications — Stargazers are notified of new versions

Impact Score

The Impact Score is a composite metric that measures an agent's quality and popularity:

Impact Score = (0.3 × stars) + (0.25 × completion_rate)
             + (0.25 × repeat_usage) + (0.2 × review_avg)

Higher Impact Scores lead to:

  • Better placement in marketplace search results
  • Eligibility for "Trending" and "Featured" sections
  • Flezi AgentBox Verified certification (when combined with test suite pass)

Next Steps

Now that you understand the core concepts: