v0.22.0

KaibanJS v0.22.0 🚀

🤖 xAI Grok Model Support (Including Grok-4)

KaibanJS now supports the latest Grok-4 model from xAI — bringing advanced LLM reasoning into your multi-agent workflows.

Alongside Grok-4, this release also adds compatibility with additional xAI variants:

• grok-3
• grok-3-mini
• grok-3-mini-fast

Whether you're building lightweight prototypes or full-scale agentic systems, KaibanJS now offers native support for all current xAI model versions.

🌐 How to Use

Add @langchain/xai to your project and configure the model via llmConfig:

const agent = new Agent({
  name: 'XAI Analyst',
  role: 'Use Grok to summarize and report on live sports events',
  llmConfig: {
    provider: "xai",
    model: "grok-4", // or "grok-3-mini-fast"
  }
});

📚 Playground + Storybook Update

We’ve added a new Grok-enabled story to the React Playground (SportNewsTeam.stories.js). This allows developers to explore Grok-powered workflows visually — no setup required.

📐 Features

• ✅ Native integration with @langchain/xai
• ✅ Full support for Grok-4, plus grok-3, grok-3-mini, and grok-3-mini-fast
• 🔐 Environment-based key detection via XAI_API_KEY
• 💰 Accurate pricing support for all Grok models in the llmCostCalculator
• 🧠 Compatibility with ReactChampionAgent and core orchestration APIs

🧪 Testing

This release includes test coverage to ensure:

• Seamless integration of Grok models across workflows
• API key handling is robust and consistent
• Cost calculation is model-aware
• Agents powered by Grok models pass validation in sportNewsTeam scenarios

🔧 Dependency Updates

• @langchain/core upgraded to ^0.3.66
• rollup upgraded to ^4.45.1
• Minor updates across the stack for improved performance and long-term compatibility

---

💡 Use Cases for xAI Model Integration

• Intelligent summarization and analysis powered by Grok-4
• Prototyping with fast, lightweight models like grok-3-mini-fast
• Running side-by-side experiments with models from OpenAI, Anthropic, and xAI
• Cost-aware orchestration of agents using Grok’s pricing profiles

---

No breaking changes were introduced.
KaibanJS now speaks Grok — from fast variants to Grok-4 itself.
Ready to build smarter agent workflows? Let's go. 🚀

v0.21.0

🔄 KaibanJS v0.21.0 – DeepSeek Integration + MCP Playground Examples

🌟 Highlight: DeepSeek Multi-Model Support + Model Context Protocol (MCP) in Playground

We’ve added official support for the DeepSeek provider with multi-model capabilities, allowing developers to use both deepseek-chat and deepseek-reasoner across agent workflows.

In addition, the React Playground has been upgraded to include DeepSeek llm examples and MCP (Model Context Protocol) examples, aligning with emerging standards for structured agent-tool interaction and enabling powerful, interoperable workflows.

---

📦 What’s New

🤖 DeepSeek Model Integration

• Introduced support for DeepSeek in agent llmConfig, with full support for:

  • deepseek-chat
  • deepseek-reasoner

• Updated the cost calculator and configuration system to reflect DeepSeek parameters

• Playground React app now includes DeepSeek-powered agent examples and enhanced Storybook demos

Agent using deepseek-chat:

const searchAgent = new Agent({
  name: 'Scout',
  role: 'Information Gatherer',
  goal: 'Find up-to-date information about the given sports input.',
  background: 'Research',
  type: 'ReactChampionAgent',
  tools: [searchTool],
  llmConfig: {
    provider: 'deepseek',
    model: 'deepseek-chat',
  },
});

Agent using deepseek-reasoner:

const profileAnalyst = new Agent({
  name: 'Mary',
  role: 'Profile Analyst',
  goal: 'Extract structured information from conversational user input.',
  background: 'Data Processor',
  tools: [],
  llmConfig: {
    provider: 'deepseek',
    model: 'deepseek-reasoner',
  },
});

🧰 Playground Enhancements

• Added DeepSeek examples to the React Playground
• Introduced MCP (Model Context Protocol) examples to demonstrate agent-tool integration using standardized context formats

🧪 Testing Improvements

• Updated tests to include DeepSeek agent workflows
• Validated configuration across DeepSeek, OpenAI, and Anthropic agents

---

🐛 Community Contribution

• [#233] Fix typos in codebase
  Huge thanks to @davidxll for your contribution! Your fixes help keep the codebase clear and developer-friendly.

---

KaibanJS continues to evolve to support the latest in LLM and multi-agent orchestration. Dive into the Playground to test DeepSeek, explore MCP workflows, and create modular AI systems faster than ever.

v0.20.0

🔄 KaibanJS v0.20.0 – LangChain Upgrade (Core + Tools)

🌟 Highlight: LangChain Dependencies Upgraded in Core & Tools

We’ve upgraded all @langchain dependencies in both the core of KaibanJS and the tools package.
This ensures:

• Full compatibility with the latest LangChain APIs
• Better performance and stability across all agent workflows
• Access to new features and configuration options in model orchestration

---

📦 What’s New

⬆️ LangChain Upgrade (Core + Tools)

• Updated @langchain packages in the KaibanJS core and tools package
• Full alignment with LangChain’s latest capabilities for tool usage, model configuration, and orchestration

🧰 Tools Enhancements

• Refactored import paths in tool stories for cleaner architecture
• Improved llmConfig flexibility with support for new parameters
• Minor improvements to JSON parsing for better error handling

📚 Documentation Updates

• Expanded tools/README.md with:
  • Clear installation instructions
  • Build steps and contributor guidelines

---

🐛 Bug Fix

• [#230] Agent fails to parse Google LLM responses when using outputSchema in Task config
  Agents now properly parse structured output from Google LLMs when a schema is defined.

---

⚠️ Disclaimer for Custom Tooling & LLM Instances

If you're using custom tools or custom LLMInstances, please review and test your implementations.
The updated LangChain dependencies include internal changes that may affect:

• Tool and agent execution behavior
• Output formatting and schema parsing
• LLM config defaults and parameter handling

v0.19.0

KaibanJS v0.19.0 🚀.

Overview

TypeScript Migration: This release introduces the TypeScript migration for KaibanJS, providing enhanced type safety and developer experience while maintaining backward compatibility.

Key Changes

• Complete conversion of JavaScript codebase to TypeScript
• Added comprehensive type definitions for core functionality
• Migrated all tools to TypeScript with proper typing
• Updated build system to handle TypeScript compilation
• Added TypeScript tests to validate type safety
• Maintained backward compatibility by preserving .js files as .deprecated.js
• Enhanced documentation with TypeScript usage examples
• Updated Jest configuration to support TypeScript tests

Tool Improvements

• All tools now include strong type definitions for inputs and outputs
• Type-safe tool registration and execution flow
• Enhanced error handling with typed error responses
• Better intellisense support when creating custom tools
• Type guards for runtime validation of tool responses

Benefits for Developers

• Improved autocompletion in modern IDEs
• Better error detection during development
• Self-documenting code with type signatures
• Enhanced refactoring capabilities
• Stronger guarantees around API contracts
• Easier custom tool creation with TypeScript interfaces

Usage

The alpha version can be installed with:

npm install kaibanjs

TypeScript users can now enjoy native type support without additional configuration.

Testing

• All existing tests have been migrated to TypeScript
• New type-specific tests have been added
• Tool-specific type tests ensure proper input/output handling
• All functionality remains identical to the JavaScript version

Migration for Existing Users

No breaking changes have been introduced for JavaScript users. The existing API remains fully compatible, and JavaScript projects using KaibanJS will continue to work without any changes.

Special Thanks

Thanks to @ernestocarrasco for their initial TypeScript migration work, which served as the foundation for this improved implementation and @anthonydevs17 for tools package migration work. Additional contributions from the community that helped refine the types and testing approach are greatly appreciated.

v0.18.0

KaibanJS v0.18.0 🚀

🎮 Features & Improvements

Workflow Execution Control

• ⏯️ Pause/Resume

  • Temporarily halt workflow execution
  • Preserve complete workflow state
  • Resume from exact pause point
  • Maintain task queue integrity

• 🛑 Stop Workflow

  • Immediate workflow termination
  • Proper resource cleanup
  • Task queue clearance
  • State reset handling

Task Orchestration

• Deterministic Execution Patterns

  new Task({
      // The referenceId is used to define dependencies between tasks
      // and track task status throughout the workflow lifecycle
      referenceId: 'data-processing',
      description: 'Process dataset batch',
      agent: processor,
      allowParallelExecution: true,    // Enable parallel processing
      dependencies: ['data-validation'] // Define task dependencies
  });

  • Sequential processing for ordered operations
  • Dependency-based execution for complex workflows
  • Parallel task support for improved performance
  • Automatic dependency resolution and validation

Enhanced Developer Experience

• Improved Observability

  • Comprehensive logging system with configurable levels
  • Real-time workflow state visualization
  • Clear task execution pattern tracking
  • Detailed performance metrics and statistics

• Robust Error Management

  • Graceful error handling with specialized abort controllers
  • State preservation during interruptions
  • Detailed error reporting and diagnostics
  • Automatic recovery mechanisms

📚 Use Cases

Content Production Pipeline

const contentTeam = new Team({
    name: 'Content Team',
    agents: [researcher, writer, editor, seoSpecialist, imageDesigner],
    tasks: [
        new Task({
            referenceId: 'topic-research',
            description: 'Research market trends and competitor content',
            agent: researcher,
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'keyword-analysis',
            description: 'Analyze SEO keywords and search intent',
            agent: seoSpecialist,
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'outline',
            description: 'Create content outline based on research',
            agent: writer,
            dependencies: ['topic-research', 'keyword-analysis']
        }),
        new Task({
            referenceId: 'draft',
            description: 'Write initial content draft',
            agent: writer,
            dependencies: ['outline']
        }),
        new Task({
            referenceId: 'images',
            description: 'Create supporting visuals',
            agent: imageDesigner,
            dependencies: ['outline'],
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'seo-optimization',
            description: 'Optimize content for search engines',
            agent: seoSpecialist,
            dependencies: ['draft'],
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'edit',
            description: 'Review and polish content',
            agent: editor,
            dependencies: ['draft', 'seo-optimization']
        }),
        new Task({
            referenceId: 'final-review',
            description: 'Final review with all assets',
            agent: editor,
            dependencies: ['edit', 'images']
        })
    ]
});

Data Processing Workflow

const dataTeam = new Team({
    name: 'Data Processing Team',
    agents: [validator, processor, analyzer, visualizer, qualityChecker],
    tasks: [
        new Task({
            referenceId: 'data-validation',
            description: 'Validate raw data integrity',
            agent: validator
        }),
        // Parallel validation tasks after initial check
        new Task({
            referenceId: 'schema-validation',
            description: 'Validate data schema compliance',
            agent: validator,
            dependencies: ['data-validation'],
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'quality-check',
            description: 'Check data quality metrics',
            agent: qualityChecker,
            dependencies: ['data-validation'],
            allowParallelExecution: true
        }),
        // Parallel processing of different data segments
        new Task({
            referenceId: 'process-segment-1',
            description: 'Process first data segment',
            agent: processor,
            dependencies: ['schema-validation', 'quality-check'],
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'process-segment-2',
            description: 'Process second data segment',
            agent: processor,
            dependencies: ['schema-validation', 'quality-check'],
            allowParallelExecution: true
        }),
        // Parallel analysis tasks
        new Task({
            referenceId: 'trend-analysis',
            description: 'Analyze trends in processed data',
            agent: analyzer,
            dependencies: ['process-segment-1', 'process-segment-2'],
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'anomaly-detection',
            description: 'Detect anomalies in processed data',
            agent: analyzer,
            dependencies: ['process-segment-1', 'process-segment-2'],
            allowParallelExecution: true
        }),
        // Parallel visualization tasks
        new Task({
            referenceId: 'trend-visualization',
            description: 'Create trend visualizations',
            agent: visualizer,
            dependencies: ['trend-analysis'],
            allowParallelExecution: true
        }),
        new Task({
            referenceId: 'anomaly-visualization',
            description: 'Create anomaly visualizations',
            agent: visualizer,
            dependencies: ['anomaly-detection'],
            allowParallelExecution: true
        }),
        // Final report compilation
        new Task({
            referenceId: 'final-report',
            description: 'Compile final analysis report',
            agent: analyzer,
            dependencies: ['trend-visualization', 'anomaly-visualization']
        })
    ]
});

🚀 Getting Started

Check out our updated documentation:

• Task Orchestration
• Workflow Control Doc
• Task Management Doc

🙏 Acknowledgments

Special thanks to:

• @anthonydevs17 for implementing the core pause/resume functionality and workflow control features
• @ernestocarrasco for the task management refactoring and test suite improvements

No breaking changes. These features maintain backward compatibility while significantly enhancing workflow control and task management capabilities.

We're excited to see how you'll use these new workflow control features in your applications! Share your experiences and feedback with us on GitHub.

v0.17.0

KaibanJS v0.17.0 🚀

Task Result Passing & Memory Management

Introducing two powerful features for managing task results and workflow context:

Task Result Passing

Reference results from previous tasks using a simple syntax:

// Create a content creation workflow
const researchTask = new Task({
    description: 'Research AI trends in 2024',
    expectedOutput: 'Key findings in JSON format',
    agent: researcher
});

const writingTask = new Task({
    description: `Write an article based on this research:
    {taskResult:task1}
    
    Focus on emerging trends and business impact.`,
    expectedOutput: 'Draft article',
    agent: writer
});

const editingTask = new Task({
    description: `Polish this article draft:
    {taskResult:task2}
    
    Enhance clarity and engagement.`,
    expectedOutput: 'Final article',
    agent: editor
});

Memory Management

Control how task results flow through your workflow:

// Enable automatic access to all previous results
const teamWithMemory = new Team({
    name: 'Content Team',
    agents: [researcher, writer, editor],
    tasks: [researchTask, writingTask, editingTask],
    memory: true  // Default: all previous results available
});

// Or require explicit result references
const performanceTeam = new Team({
    name: 'Data Processing Team',
    agents: [processor, analyzer],
    tasks: [processTask, analyzeTask],
    memory: false  // Only explicitly referenced results available
});

Features

Task Result Passing

• Simple {taskResult:taskN} syntax
• 1-based task indexing
• Automatic result interpolation
• Clear dependency tracking

Memory Management

• Team-level memory configuration
• Automatic vs. explicit result access
• Optimized token usage options
• Enhanced workflow control

Use Cases

Task Result Passing

• Multi-step content creation
• Data processing pipelines
• Sequential analysis workflows
• Iterative refinement processes

Memory Management

• Large-scale workflows
• Token-sensitive operations
• Complex agent interactions
• Performance-critical systems

Getting Started

Check out our guides:

• Task Result Passing Guide
• Memory Management Guide

No breaking changes. These features maintain backward compatibility while enhancing workflow capabilities.

v0.16.0

KaibanJS v0.16.0 🚀

Task Blocking

Introducing task blocking functionality:

// Configure agent with task blocking capability
const agent = new Agent({
    name: 'Security Validator',
    role: 'Security Clearance Checker',
    goal: 'Validate security requirements',
    kanbanTools: ['block_task']
});

// Create a task requiring security validation
const task = new Task({
    description: `Review this data access request:
    - User: john.doe
    - Resource: customer_financial_records
    - Clearance: none
    
    Block the task if security requirements aren't met.`,
    agent: agent
});

// Agent's decision to block (example response)
{
    "thought": "User lacks required security clearance for financial records",
    "action": "block_task",
    "actionInput": {
        "reason": "Access denied: No security clearance for financial data"
    }
}

// Handle blocked tasks in your application
team.start()
    .then((output) => {
        if (output.status === 'BLOCKED') {
            console.log('Task blocked:', output.result);
        }
    });

Features

• New kanbanTools property for agents
• block-task-tool: First Kanban tool for workflow control
• Automatic status updates when tasks are blocked
• Built-in metadata tracking (reason, agent, context)

Use Cases

• Security validation
• Quality control gates
• Compliance checks
• Resource management
• Prerequisite verification

Getting Started

Check out our Kanban Tools guide to implement task blocking in your workflows.

No breaking changes. This is a feature addition that maintains backward compatibility.

v0.15.0

KaibanJS v0.15.0 🚀

🌟 Team Insights

Introducing a powerful new way to share knowledge and historical data across all agents in your AI teams:

• All agents in the team automatically receive insights through their system messages
• Historical data and patterns available throughout the entire workflow
• Enables coordinated decision-making across agents
• Maintains context consistency between tasks

const team = new Team({
name: 'Passenger Experience Team',
agents: [profileAnalyst, recommendationAgent],
tasks: [analysisTask, recommendationTask],
insights: `
   Passenger Profile: FF-789321 Travel History (2023): 
   
   1. Seating: Window seats (87% of flights) 
   2. Dining: Asian Vegetarian meals 
   3. Lounge: Terminal 4 (avg. 2.5hr stays) 
   4. Previous Issues: Delays on DXB-892`
});

💡 Use Case: Airline Passenger Experience

Team Insights enables agents to:

• Access passenger travel history and preferences
• Make informed recommendations based on past experiences
• Consider previous feedback and issues
• Deliver personalized service across all interaction points

🎯 Getting Started

Check out our Team Insights documentation to learn how to enhance your teams with shared knowledge and experience.

We're excited to see how you'll use Team Insights to make your AI teams smarter and more effective! Share your creations and feedback with us on GitHub.

v0.14.2

KaibanJS v0.14.2 🚀

Dynamic Environment Updates

Bug Fixes 🐛

• Fixed environment variable updates not being propagated to OpenAI API calls (#215)
• Added proper error handling for API response recording in MoscaFetch

Key Updates ✨

• Added dynamic environment update support for running agents
• Enhanced API key management with environment-first retrieval
• Improved team store environment propagation
• Added comprehensive test coverage for environment updates

Key Capabilities

• 🔄 Real-time environment variable updates
• 🔑 Dynamic API key management
• 🛡️ Automatic propagation to all agents
• ✅ Immediate effect on API calls
• 📊 Full workflow state preservation

Use Cases

These environment update capabilities enable:

• Dynamic API key rotation
• Environment-specific configuration changes
• Runtime credential updates
• Seamless workflow continuation after config changes

Some example applications:

• Update API keys without restarting workflows
• Switch between different OpenAI organizations
• Modify agent configurations mid-workflow
• Handle token expiration gracefully

Contributors

Special thanks to @aaron5670 for reporting this critical issue! 🙏

PR #216
Issue #215

v0.14.1

KaibanJS v0.14.1 🚀

TypeScript Configuration Update

Bug Fixes 🐛

• Fixed Team creation crash when 'Agent' attribute was missing (#73)
• Enhanced type definitions for better development experience (#205)

Key Updates ✨

• Updated TypeScript configuration for better module resolution
• Improved path aliases for imports
• Enhanced type safety across the codebase

Contributors

Special thanks to @anthonydevs17 for their valuable contributions! 🙏

PR #205
Issue #73