Claude Code Plugins

Community-maintained marketplace

Feedback

kaizen

@Integrum-Global/new_project_template
0
0

Kailash Kaizen - production-ready AI agent framework with signature-based programming, multi-agent coordination, and enterprise features. Use when asking about 'AI agents', 'agent framework', 'BaseAgent', 'multi-agent systems', 'agent coordination', 'signatures', 'agent signatures', 'RAG agents', 'vision agents', 'audio agents', 'multimodal agents', 'agent prompts', 'prompt optimization', 'chain of thought', 'ReAct pattern', 'Planning agent', 'PEV agent', 'Tree-of-Thoughts', 'pipeline patterns', 'supervisor-worker', 'router pattern', 'ensemble pattern', 'blackboard pattern', 'parallel execution', 'agent-to-agent communication', 'A2A protocol', 'streaming agents', 'agent testing', 'agent memory', or 'agentic workflows'.

Install Skill

1Download skill
2Enable skills in Claude

Open claude.ai/settings/capabilities and find the "Skills" section

3Upload to Claude

Click "Upload skill" and select the downloaded ZIP file

Note: Please verify skill by going through its instructions before using it.

SKILL.md

name kaizen
description Kailash Kaizen - production-ready AI agent framework with signature-based programming, multi-agent coordination, and enterprise features. Use when asking about 'AI agents', 'agent framework', 'BaseAgent', 'multi-agent systems', 'agent coordination', 'signatures', 'agent signatures', 'RAG agents', 'vision agents', 'audio agents', 'multimodal agents', 'agent prompts', 'prompt optimization', 'chain of thought', 'ReAct pattern', 'Planning agent', 'PEV agent', 'Tree-of-Thoughts', 'pipeline patterns', 'supervisor-worker', 'router pattern', 'ensemble pattern', 'blackboard pattern', 'parallel execution', 'agent-to-agent communication', 'A2A protocol', 'streaming agents', 'agent testing', 'agent memory', 'agentic workflows', 'AgentRegistry', 'OrchestrationRuntime', 'distributed agents', 'agent registry', '100+ agents', 'capability discovery', 'fault tolerance', or 'health monitoring'.

Kailash Kaizen - AI Agent Framework

Kaizen is a production-ready AI agent framework built on Kailash Core SDK that provides signature-based programming and multi-agent coordination.

Features

Kaizen enables building sophisticated AI agents with:

  • Signature-Based Programming: Type-safe agent interfaces with automatic validation and optimization
  • BaseAgent Architecture: Production-ready agent foundation with error handling, audit trails, and cost tracking
  • Multi-Agent Coordination: Supervisor-worker, agent-to-agent protocols, hierarchical structures
  • Orchestration Patterns: 9 composable patterns (Ensemble, Blackboard, Router, Parallel, Sequential, Supervisor-Worker, Handoff, Consensus, Debate)
  • Multimodal Processing: Vision, audio, and text processing capabilities
  • Autonomy Infrastructure: 6 integrated subsystems (Hooks, Checkpoint, Interrupt, Memory, Planning, Meta-Controller)
  • Distributed Coordination: AgentRegistry for 100+ agent systems with O(1) capability discovery
  • Enterprise Features: Cost tracking, streaming responses, automatic optimization
  • Memory System: 3-tier hierarchical storage (Hot/Warm/Cold) with DataFlow backend
  • Security: RBAC, process isolation, compliance controls (SOC2, GDPR, HIPAA, PCI-DSS)

Quick Start

Basic Agent

from kaizen.core.base_agent import BaseAgent
from kaizen.signatures import Signature, InputField, OutputField
from dataclasses import dataclass

# Define agent signature (type-safe interface)
class SummarizeSignature(Signature):
    text: str = InputField(description="Text to summarize")
    summary: str = OutputField(description="Generated summary")

# Define configuration
@dataclass
class SummaryConfig:
    llm_provider: str = "openai"
    model: str = "gpt-4"
    temperature: float = 0.7

# Create agent with signature
class SummaryAgent(BaseAgent):
    def __init__(self, config: SummaryConfig):
        super().__init__(
            config=config,
            signature=SummarizeSignature()
        )

# Execute
agent = SummaryAgent(SummaryConfig())
result = agent.run(text="Long text here...")
print(result['summary'])

Pipeline Patterns (Orchestration)

from kaizen.orchestration.pipeline import Pipeline

# Ensemble: Multi-perspective collaboration
pipeline = Pipeline.ensemble(
    agents=[code_expert, data_expert, writing_expert, research_expert],
    synthesizer=synthesis_agent,
    discovery_mode="a2a",  # A2A semantic matching
    top_k=3                # Select top 3 agents
)

# Execute - automatically selects best agents for task
result = pipeline.run(task="Analyze codebase", input="repo_path")

# Router: Intelligent task delegation
router = Pipeline.router(
    agents=[code_agent, data_agent, writing_agent],
    routing_strategy="semantic"  # A2A-based routing
)

# Blackboard: Iterative problem-solving
blackboard = Pipeline.blackboard(
    agents=[solver, analyzer, optimizer],
    controller=controller,
    max_iterations=10,
    discovery_mode="a2a"
)

Reference Documentation

Comprehensive Guides

For in-depth documentation, see apps/kailash-kaizen/docs/:

Core Guides:

Reference Documentation:

Quick Start (Skills)

Agent Patterns

Multi-Agent Systems & Orchestration

Pipeline Patterns (9 Composable Patterns):

  • Ensemble: Multi-perspective collaboration with A2A discovery + synthesis
  • Blackboard: Controller-driven iterative problem-solving
  • Router (Meta-Controller): Intelligent task routing via A2A matching
  • Parallel: Concurrent execution with aggregation
  • Sequential: Linear agent chain
  • Supervisor-Worker: Hierarchical coordination
  • Handoff: Agent handoff with context transfer
  • Consensus: Voting-based decision making
  • Debate: Adversarial deliberation

Multimodal Processing

Advanced Features

Observability & Monitoring

Testing & Quality

Key Concepts

Signature-Based Programming

Signatures define type-safe interfaces for agents:

  • Input: Define expected inputs with descriptions
  • Output: Specify output format and structure
  • Validation: Automatic type checking and validation
  • Optimization: Framework can optimize prompts automatically

BaseAgent Architecture

Foundation for all Kaizen agents:

  • Error Handling: Built-in retry logic and error recovery
  • Audit Trails: Automatic logging of agent actions
  • Cost Tracking: Monitor API usage and costs
  • Streaming: Support for streaming responses
  • Memory: State management across invocations
  • Hooks System: Zero-code-change observability and lifecycle management

Autonomy Infrastructure (6 Subsystems)

1. Hooks System - Event-driven observability framework

  • Zero-code-change monitoring via lifecycle events (PRE/POST hooks)
  • 6 builtin hooks: Logging, Metrics, Cost, Performance, Audit, Tracing
  • Production security: RBAC, Ed25519 signatures, process isolation, rate limiting
  • Performance: <0.01ms overhead (625x better than 10ms target)

2. Checkpoint System - Persistent state management

  • Save/load/fork agent state for failure recovery
  • 4 storage backends: Filesystem, Redis, PostgreSQL, S3
  • Automatic compression and incremental checkpoints
  • State manager with deduplication and versioning

3. Interrupt Mechanism - Graceful shutdown and execution control

  • 3 interrupt sources: USER (Ctrl+C), SYSTEM (timeout/budget), PROGRAMMATIC (API)
  • 2 shutdown modes: GRACEFUL (finish cycle + checkpoint) vs IMMEDIATE (stop now)
  • Signal propagation across multi-agent hierarchies

4. Memory System - 3-tier hierarchical storage

  • Hot tier: In-memory buffer (<1ms retrieval, last 100 messages)
  • Warm tier: Database (10-50ms, agent-specific history with JSONL compression)
  • Cold tier: Object storage (100ms+, long-term archival with S3/MinIO)
  • DataFlow-backed with auto-persist and cross-session continuity

5. Planning Agents - Structured workflow orchestration

  • PlanningAgent: Plan before you act (pre-execution validation)
  • PEVAgent: Plan, Execute, Verify, Refine (iterative refinement)
  • Tree-of-Thoughts: Explore multiple reasoning paths
  • Multi-step decomposition, validation, and replanning

6. Meta-Controller Routing - Intelligent task delegation

  • A2A-based semantic capability matching (no hardcoded if/else)
  • Automatic agent discovery, ranking, and selection
  • Fallback strategies and load balancing
  • Integrated with Router, Ensemble, and Supervisor-Worker patterns

AgentRegistry - Distributed Coordination

For 100+ agent distributed systems:

  • O(1) capability-based discovery with semantic matching
  • Event broadcasting (6 event types for cross-runtime coordination)
  • Health monitoring with automatic deregistration
  • Status management (ACTIVE, UNHEALTHY, DEGRADED, OFFLINE)
  • Multi-runtime coordination across processes/machines

When to Use This Skill

Use Kaizen when you need to:

  • Build AI agents with type-safe interfaces
  • Implement multi-agent systems with orchestration patterns
  • Process multimodal inputs (vision, audio, text)
  • Create RAG (Retrieval-Augmented Generation) systems
  • Implement chain-of-thought reasoning
  • Build supervisor-worker or ensemble architectures
  • Track costs and performance of AI agents
  • Add zero-code-change observability to agents
  • Monitor, trace, and audit agent behavior in production
  • Secure agent observability with RBAC and compliance controls
  • Create production-ready agentic applications

Use Pipeline Patterns When:

  • Ensemble: Need diverse perspectives synthesized (code review, research)
  • Blackboard: Iterative problem-solving (optimization, debugging)
  • Router: Intelligent task delegation to specialists
  • Parallel: Bulk processing or voting-based consensus
  • Sequential: Linear workflows with dependency chains

Integration Patterns

With DataFlow (Data-Driven Agents)

from kaizen.core.base_agent import BaseAgent
from dataflow import DataFlow

class DataAgent(BaseAgent):
    def __init__(self, config, db: DataFlow):
        self.db = db
        super().__init__(config=config, signature=MySignature())

With Nexus (Multi-Channel Agents)

from kaizen.core.base_agent import BaseAgent
from nexus import Nexus

# Deploy agents via API/CLI/MCP
agent_workflow = create_agent_workflow()
nexus = Nexus([agent_workflow])
nexus.run()  # Agents available via all channels

With Core SDK (Custom Workflows)

from kaizen.core.base_agent import BaseAgent
from kailash.workflow.builder import WorkflowBuilder

# Embed agents in workflows
workflow = WorkflowBuilder()
workflow.add_node("KaizenAgent", "agent1", {
    "agent": my_agent,
    "input": "..."
})

Critical Rules

  • ✅ Define signatures before implementing agents
  • ✅ Extend BaseAgent for production agents
  • ✅ Use type hints in signatures for validation
  • ✅ Track costs in production environments
  • ✅ Test agents with real infrastructure (NO MOCKING)
  • ✅ Enable hooks for observability
  • ✅ Use AgentRegistry for distributed coordination
  • ❌ NEVER skip signature definitions
  • ❌ NEVER ignore cost tracking in production
  • ❌ NEVER mock LLM calls in integration tests

Related Skills

Support

For Kaizen-specific questions, invoke:

  • kaizen-specialist - Kaizen framework implementation
  • testing-specialist - Agent testing strategies
  • framework-advisor - When to use Kaizen vs other frameworks