Integrating KaibanJS Teams with Kaiban Platform via A2A Protocol
Discover how the Kaiban platform enables seamless interoperability between AI agents built with any SDK. This example demonstrates integrating a KaibanJS revenue management team with the Kaiban platform using the standardized A2A protocol for enterprise workflow automation.
Universal Interoperability with the Kaiban Platform
The Kaiban platform provides enterprise workflow management and agent orchestration capabilities that work seamlessly with agents built using any SDK or framework. Through the standardized A2A (Agent-to-Agent) protocol, agents implemented with KaibanJS can integrate directly into the Kaiban platform, enabling powerful workflow automation, card-based task management, and real-time collaboration.
This example showcases how a KaibanJS team for airline revenue management analysis can be integrated with the Kaiban platform. When cards are created or updated in a Kaiban board, the platform communicates with the agent via the A2A protocol, triggering the KaibanJS team execution and automatically updating card statuses through the workflow lifecycle (TODO → DOING → DONE → BLOCKED).
The Challenge: Integrating AI Agents with Enterprise Platforms
Organizations need to integrate AI agents into their existing workflow management systems, but traditional approaches often require custom integrations, vendor lock-in, or proprietary protocols that limit flexibility.
Vendor Lock-in
Proprietary platforms often require using specific SDKs or frameworks, limiting your ability to leverage best-in-class agent development tools.
Complex Integration
Building custom integrations between agent frameworks and workflow platforms requires significant development effort and ongoing maintenance.
Lack of Standards
Without standardized protocols, each integration becomes a one-off solution that doesn't scale across teams or platforms.
Workflow Fragmentation
Agents and workflow management systems operate in isolation, making it difficult to track progress, collaborate, and maintain visibility.
The Solution: A2A Protocol Integration with Kaiban Platform
The Kaiban platform's A2A protocol integration enables any agent built with any SDK (including KaibanJS) to seamlessly integrate with enterprise workflow management. This approach provides standardized communication, automatic workflow orchestration, and real-time status updates.
SDK Agnostic
The Kaiban platform works with agents built using any SDK or framework, including KaibanJS, LangChain, AutoGen, and others. No vendor lock-in required.
A2A Protocol Standard
Communication follows the standardized A2A protocol, ensuring compatibility, security, and interoperability across different agent implementations.
Automatic Workflow Management
Card statuses automatically transition through workflow stages (TODO → DOING → DONE → BLOCKED) based on agent execution, providing visibility and traceability.
Real-time Integration
Agents receive activities from the Kaiban platform in real-time, process requests, and update cards automatically, enabling seamless collaboration.
Integration Architecture
Understanding how KaibanJS teams integrate with the Kaiban platform through the A2A protocol
Agent Registration
Register your agent in the Kaiban platform by providing the agent card URL (served at /.well-known/agent-card.json) and agent endpoint URL. The platform uses the agent card for discovery and capability negotiation.
Card Activity Events
When cards are created, updated, or moved in a Kaiban board, the platform sends A2A protocol messages containing Kaiban activity data to the registered agent endpoint. Activities include card creation, column changes, status updates, and agent assignments.
A2A Executor Processing
The A2A executor receives the activity, extracts the card description and context, and delegates processing to the Kaiban controller. The executor manages the task lifecycle (submitted → working → completed) as defined by the A2A protocol.
KaibanJS Team Execution
The Kaiban controller invokes the KaibanJS team with the card description. The team processes the request (in this case, analyzing revenue management data from Excel files) and generates results using collaborative AI agents.
Workflow State Updates
The Kaiban controller uses the Kaiban SDK to update card statuses automatically: moving cards to DOING during processing, to DONE upon successful completion, or to BLOCKED on errors. All state transitions are logged as activities for audit trails.
Key Components
- ✓Agent Card: Defines agent capabilities, endpoints, and A2A protocol version compatibility
- ✓A2A Executor: Implements the A2A protocol executor interface, handling task lifecycle and activity processing
- ✓Kaiban Controller: Orchestrates workflow state management and integrates with Kaiban platform APIs
- ✓KaibanJS Team: Multi-agent system that processes business logic using collaborative AI agents
- ✓Kaiban SDK: Client library for interacting with Kaiban platform APIs (cards, activities, boards)
Implementation Details: Revenue Management Use Case
This example demonstrates integrating a KaibanJS team that performs airline revenue management analysis with the Kaiban platform
KaibanJS Team Structure
The revenue management team uses a WorkflowDrivenAgent with three sequential workflow steps:
Workflow Steps:
- Extract URL and Routes: Extracts Excel file URL and route information from the card description using an extraction team
- Download and Parse Excel: Downloads the Excel file, parses it, and extracts route-specific data (CY Forecast, PY Data, Competitor Fares)
- Execute Analysis: Runs the revenue management analysis team that calculates optimal fare recommendations based on competitor pricing, load factors, demand trends, and market positioning
A2A Protocol Integration
The integration follows the A2A protocol standard for agent communication:
Protocol Components:
- • Agent Card: Served at
/airlineRevenueManagement/a2a/.well-known/agent-card.json, defines agent metadata and capabilities - • Message Endpoint: Handles POST requests at
/airlineRevenueManagement/a2awith A2A protocol messages - • Kaiban Activities: Messages contain KaibanActivityPart data with card information, board context, and activity types (CARD_CREATED, CARD_COLUMN_CHANGED, etc.)
- • Task Lifecycle: Executor publishes status updates (submitted → working → completed) via the A2A event bus
Workflow Lifecycle: Card Status Management
Card Created
User creates a card in the Kaiban board with a description containing the Excel URL and route information. The platform sends a CARD_CREATED activity to the agent.
Processing Started
The agent moves the card to DOING, updates the status, and begins processing. The KaibanJS team extracts data and executes the revenue management analysis.
Analysis Complete
Upon successful completion, the card is updated with analysis results, moved to DONE, and completion activities are logged. Results include fare recommendations and justifications.
Error Handling
If processing fails (e.g., invalid Excel format, missing route), the card is moved to BLOCKED with error details for manual review and intervention.
Interactive Demo
See how the KaibanJS revenue management team integrates with the Kaiban platform through the A2A protocol
Demo: KaibanJS Team Integration with Kaiban Platform
Watch how cards created in the Kaiban platform trigger the KaibanJS revenue management team, which processes Excel data and automatically updates card statuses through the workflow lifecycle.
View Source Code on GitHubBenefits of Kaiban Platform Integration
| Kaiban Platform Integration | Traditional Approach |
|---|---|
| SDK Agnostic | Works with agents built using any SDK or framework (KaibanJS, LangChain, AutoGen, etc.) |
| Standardized Protocol | Uses the A2A protocol standard, ensuring interoperability and reducing integration complexity |
| Automatic Workflow Management | Cards automatically transition through workflow states based on agent execution |
| Enterprise Visibility | Full audit trail of activities, status changes, and agent interactions in one centralized platform |
| Real-time Collaboration | Teams can collaborate on cards, assign agents, and track progress in real-time through the Kaiban board interface |
Getting Started with Kaiban Platform Integration
Ready to integrate your KaibanJS teams with the Kaiban platform? Follow these steps to get started
1. Clone the Starter Repository
Start with the kaiban-agents-starter repository which includes the revenue management example and A2A protocol integration setup.
git clone https://github.com/kaiban-ai/kaiban-agents-starter.git2. Configure Environment Variables
Set up your Kaiban platform credentials and agent configuration:
KAIBAN_TENANT=your-tenant
KAIBAN_API_TOKEN=your-token
KAIBAN_AGENT_ID=your-agent-id
A2A_BASE_URL=your-public-url3. Register Your Agent
Register your agent in the Kaiban platform dashboard using the agent card URL and endpoint URL. The platform will discover your agent capabilities and enable integration.
4. Assign to a Board
Assign your agent to a Kaiban board. When cards are created or updated, the platform will send activities to your agent via the A2A protocol, triggering your KaibanJS team execution.
Ready to Integrate Your Agents with Kaiban Platform?
The Kaiban platform provides enterprise workflow management that works seamlessly with agents built using any SDK. Start integrating your KaibanJS teams today and unlock powerful workflow automation capabilities.
We’re almost there! 🌟 Help us hit 100 stars!
Star KaibanJS - Only 100 to go! ⭐