Blocks

Blocks are the building components you connect together to create AI workflows. Think of them as specialized modules that each handle a specific task—from chatting with AI models to making API calls or processing data.

Demo: dragging a few blocks onto the canvas and wiring them up — the basic editor flow. (Video coming soon.)

Core Block Types

MyBotBox provides seven core block types that handle the essential functions of AI workflows:

Processing Blocks

• Agent - Chat with AI models (OpenAI, Anthropic, Google, local models)
• Function - Run custom JavaScript/TypeScript code
• API - Connect to external services via HTTP requests

Logic Blocks

• Condition - Branch workflow paths based on boolean expressions
• Router - Use AI to intelligently route requests to different paths
• Evaluator - Score and assess content quality using AI

Output Blocks

• Response - Format and return final results from your workflow

How Blocks Work

Each block has three main components:

Inputs: Data coming into the block from other blocks or user input Configuration: Settings that control how the block behaves Outputs: Data the block produces for other blocks to use

Connecting Blocks

You create workflows by connecting blocks together. The output of one block becomes the input of another:

• Drag to connect: Drag from an output port to an input port
• Multiple connections: One output can connect to multiple inputs
• Branching paths: Some blocks can route to different paths based on conditions

Demo: drawing a connection between an output port and an input port to wire two blocks. (Video coming soon.)

Common Patterns

Sequential Processing

Connect blocks in a chain where each block processes the output of the previous one:

User Input → Agent → Function → Response

Conditional Branching

Use Condition or Router blocks to create different paths:

User Input → Router → Agent A (for questions)
                   → Agent B (for commands)

Quality Control

Use Evaluator blocks to assess and filter outputs:

Agent → Evaluator → Condition → Response (if good)
                              → Agent (retry if bad)

Block Configuration

Each block type has specific configuration options:

All Blocks:

• Input/output connections
• Error handling behavior
• Execution timeout settings

AI Blocks (Agent, Router, Evaluator):

• Model selection (OpenAI, Anthropic, Google, local)
• API keys and authentication
• Temperature and other model parameters
• System prompts and instructions

Logic Blocks (Condition, Function):

• Custom expressions or code
• Variable references
• Execution environment settings

Integration Blocks (API, Response):

• Endpoint configuration
• Headers and authentication
• Request/response formatting

Agentic AI Blocks

MyBotBox now includes advanced agentic AI blocks that enable sophisticated autonomous behavior, learning, and collaboration:

Reasoning & Planning

• ReAct Loop - Iterative reasoning and action cycles for complex problem-solving
• Goal Planner - Autonomous goal decomposition and task planning
• Self-Reflection - Metacognitive analysis and self-improvement

Memory & Knowledge

• Persistent Memory - Long-term information storage across sessions
• Episodic Memory - Sequential conversation history and temporal context
• Knowledge Graph - Relationship-based knowledge networks

Orchestration & Coordination

• Multi-Agent Team - Coordinate multiple specialized agents
• Dynamic Workflow - Adaptive workflow generation based on requirements
• Event Trigger - Reactive automation and scheduled execution

Learning & Optimization

• Feedback Loop - Continuous improvement from user feedback
• Auto-Optimization - Automated parameter tuning and performance improvement
• A/B Testing - Controlled experiments and data-driven optimization

Research & Analysis

• Research Agent - Comprehensive multi-source information gathering
• Knowledge Graph - Advanced relationship discovery and context retrieval

Autonomy & Adaptation

• Persistent 24/7 Agent - Continuously running autonomous agents
• Goal Setter - Autonomous objective identification and prioritization
• Cross-Agent Learning - Shared knowledge across agent networks
• Plan with Backtracking - Adaptive planning with alternative exploration
• Self-Modification - Agent self-improvement and behavior adaptation