IB-X Platform Components
Overview
The IB-X Platform Components view provides a high-level structural overview of the major building blocks of IB-X and how they relate to one another.
This diagram is intentionally component-focused (what exists and how it connects) and is best read as:
- Left: design and configuration tools used to build automation
- Center: platform control and monitoring
- Right: runtime consumption via Agents, applications, and AI services
🖼️ Reference diagram:
IB-X Platform Components(the component architecture image shown above)
Key Concepts
Agents as the Core Runtime Unit
In IB-X, all automation is expressed as Agents. Agents can implement deterministic automation, intelligent decisioning, or a hybrid of both. At runtime, Agents execute activities to interact with applications and optionally leverage AI services.
Control Plane vs Execution Flow
The component view shows how design-time tools and runtime agents are governed through the AI Command Center, which acts as the control plane for deployment, governance, and monitoring.
Design-Time Components (Left Side)
These tools are used to build and configure IB-X solutions.
Action Builder
The Action Builder is the primary design environment for creating and configuring Agents in IB-X.
It is used to:
- Define agent workflows, logic, and execution paths
- Compose automation using reusable actions and activities
- Configure integrations with business applications, APIs, and data sources
- Invoke AI capabilities by using AI-enabled activities when required
- Package, version, and publish agents for deployment and execution
All agents—whether they perform purely deterministic automation or leverage AI capabilities—are designed using the same Action Builder and follow a single, unified agent model.
📘 Learn more: Action Builder
Process Designer (Local Agents)
The Process Designer (also referred to as the Local Agent Designer) is used to design Local Agents that require execution inside the customer’s network.
It is intended for automation that must interact with:
- Web applications (UI automation)
- Desktop applications (UI automation)
- On-premise / legacy systems accessible only within the customer environment
IB-X centrally governs Local Agents designed here but executed in the customer environment.
📘 Learn more: Process Designer – Local Agents
Form Designer
The Form Designer is used to create human interaction forms that agents require during execution.
It enables scenarios such as:
- Approvals and reviews
- Human-in-the-loop decision points
- Structured data input
- Capturing contextual information required to proceed
Forms can be reused across multiple agents and are part of building end-to-end business automation.
📘 Learn more: Form Designer
IntelliTrainer
IntelliTrainer enables template-based document training and extraction.
It is designed for OCR-driven document layout learning and supports:
- Training document layouts as reusable templates
- Mapping structured and semi-structured fields within documents
- OCR-based extraction of text and positional information
- Repeatable extraction from standardized business documents (invoices, forms, statements, etc.)
IntelliTrainer operates independently of third-party AI and does not require prompts or LLM-based processing.
📘 Learn more: IntelliTrainer
Platform Control & Monitoring (Center)
AI Command Center
The AI Command Center is the centralized control plane of IB-X.
It provides capabilities to:
- Deploy agents and manage versions
- Monitor executions and operational health
- Govern access, policies, and audit trails
- Track platform usage and consumption
- Manage users, environments, and security controls
In the diagram, the AI Command Center is shown as the platform hub that connects design-time tools to runtime agent execution.
📘 Learn more: AI Command Center
Agent Monitoring Consoles
The Agent Monitoring Consoles are the monitoring and management views within the AI Command Center for observing and controlling Agent executions.
In IB-X, these consoles are not a separate monitoring subsystem. They are backed entirely by persisted execution instances of Agents.
Each Agent execution creates an execution instance, which captures:
- Execution lifecycle state (created, running, completed, failed, cancelled)
- Inputs, outputs, and execution context
- Detailed logs and step-level traces
- Errors, retries, and exception details
- Timing and performance metadata
These execution instances are stored in the AI Command Center backend database and serve as the single source of truth for monitoring and governance.
Through the Agent Monitoring Consoles, users can:
- Track running and completed Agent executions
- Inspect logs and execution details
- Identify failures and performance issues
- Take operational actions such as retry, cancel, or reschedule executions
- Audit historical executions for compliance and analysis
This design ensures that execution, monitoring, and management are unified, with no separation between runtime behavior and operational visibility.
📘 Learn more: Monitoring & Observability
Runtime & External Dependencies (Right Side)
IB Agents (Automation / Conversational)
IB Agents are the published automation artifacts produced through the design-time tools in IB-X.
When an IB Agent is executed, the platform creates one or more execution instances that represent the runtime behavior of that agent. These execution instances are persisted and managed within the AI Command Center.
At runtime, IB Agents can:
- Execute deterministic automation steps
- Trigger application integrations through activities
- Invoke AI or conversational capabilities when required
- Combine deterministic execution and intelligent decisioning in hybrid scenarios
Execution instances of IB Agents may run centrally within the AI Command Center or may delegate specific steps to customer-network execution when Local Agents are involved.
All execution instances can be tracked, monitored, and managed through the AI Command Center.
Applications
Applications represent the target systems that agents interact with, such as:
- Enterprise business applications (ERP/CRM)
- Internal portals and web apps
- Desktop applications
- Data systems and APIs
Agents interact with applications primarily through Activities and connectors, configured within the agent design.
AI Services (Integration Gateway / Bring Your Own Keys)
AI Services represent the intelligence layer that Agents consume.
IB-X supports two ways to use these services:
Integration Gateway (Managed AI Services)
- IB-X wraps and exposes third-party AI/cognitive capabilities as managed services
- Consumption is tracked and charged through IB-X Currency
- Common use cases include LLM calls and cognitive processing services
Bring Your Own Keys (BYOK)
- Customers provide their own service keys for providers such as OpenAI or Azure
- IB-X uses customer credentials during execution
- Customers retain control over provider choice, spend, and compliance posture
📘 Learn more: AI Services – Managed vs BYOK
Typical Interaction Flow (High-Level)
A common high-level flow implied by this component view is:
- Users design Agents using Action Builder (and Local Agents using Process Designer).
- Human interactions are modeled via Form Designer, and document templates are created via IntelliTrainer.
- Agents are deployed and governed via the AI Command Center.
- During execution, IB Agents interact with Applications and optionally call AI Services (Managed or BYOK).
- Execution health, logs, and operational insights are viewed through Agent Monitoring Consoles.