Add Kaleidoscope chat interface and improve organon creation

- Created chat_with_kaleidoscope.py adapted from organon chat interface
- Added kaleidoscope-central agent search with lens tag support
- Updated UI with Kaleidoscope branding and lens-specific colors/icons
- Improved create_organon.py with proper config loading and error handling

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[e-mail]>

organon/chat_with_kaleidoscope.py

···
+#!/usr/bin/env python3
+"""
+Simple CLI tool to converse with the Kaleidoscope collective.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+from letta_client import Letta
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.panel import Panel
+from rich.text import Text
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config_loader import get_config
+
+load_dotenv()
+
+class KaleidoscopeChat:
+    def __init__(self):
+        """Initialize the Kaleidoscope chat client."""
+        self.console = Console()
+        self.config = get_config()
+        
+        # Initialize Letta client
+        self.letta_client = Letta(
+            base_url=self.config.get('letta.base_url', os.environ.get('LETTA_BASE_URL')),
+            token=self.config.get('letta.api_key', os.environ.get('LETTA_API_KEY')),
+            timeout=self.config.get('letta.timeout', 30)
+        )
+        
+        # Get project ID
+        self.project_id = self.config.get('letta.project_id', os.environ.get('LETTA_PROJECT_ID'))
+        if not self.project_id:
+            raise ValueError("Project ID must be set in config.yaml under letta.project_id or as LETTA_PROJECT_ID environment variable")
+        
+        # Find the Kaleidoscope collective group
+        self.group_id = self._find_kaleidoscope_group()
+        
+        self.console.print(Panel.fit(
+            "[bold cyan]Kaleidoscope Collective Chat[/bold cyan]\n"
+            f"Connected to group: {self.group_id}\n"
+            "Type 'exit' or 'quit' to leave, 'help' for commands",
+            title="🔮 Kaleidoscope Chat"
+        ))
+    
+    def _find_kaleidoscope_group(self) -> str:
+        """Find the Kaleidoscope collective group."""
+        try:
+            self.console.print("[dim]Searching for Kaleidoscope collective group...[/dim]")
+            
+            # First, get the kaleidoscope-central agent ID
+            kaleidoscope_agents = self.letta_client.agents.list(name="kaleidoscope-central")
+            if not kaleidoscope_agents:
+                raise ValueError("Kaleidoscope central agent not found. Run create_kaleidoscope.py first.")
+            
+            kaleidoscope_central_id = kaleidoscope_agents[0].id
+            self.console.print(f"[dim]Found kaleidoscope-central: {kaleidoscope_central_id[:8]}[/dim]")
+            
+            # Get all groups (with and without project_id filter)
+            try:
+                groups = self.letta_client.groups.list()
+                self.console.print(f"[dim]Found {len(groups)} groups with project filter[/dim]")
+            except:
+                try:
+                    groups = self.letta_client.groups.list()
+                    self.console.print(f"[dim]Found {len(groups)} groups without project filter[/dim]")
+                except:
+                    groups = []
+                    self.console.print("[dim]No groups found[/dim]")
+            
+            # Look for groups with kaleidoscope-central as supervisor
+            for group in groups:
+                if hasattr(group, 'manager_config') and group.manager_config:
+                    if hasattr(group.manager_config, 'manager_agent_id') and group.manager_config.manager_agent_id == kaleidoscope_central_id:
+                        self.console.print(f"[dim]Found Kaleidoscope group: {group.id[:12]}[/dim]")
+                        return group.id
+            
+            # Look for the kaleidoscope group by description
+            for group in groups:
+                if hasattr(group, 'description') and group.description and 'the kaleidoscope' in group.description.lower():
+                    self.console.print(f"[dim]Found Kaleidoscope group by description: {group.id[:12]}[/dim]")
+                    return group.id
+            
+            # If still not found, try to find any group with kaleidoscope lenses
+            lens_agents = self.letta_client.agents.list(project_id=self.project_id, tags=["kaleidoscope-lens"])
+            if lens_agents:
+                lens_ids = {lens.id for lens in lens_agents}
+                for group in groups:
+                    try:
+                        members = self.letta_client.groups.agents.list(group_id=group.id)
+                        member_ids = {member.id for member in members}
+                        if lens_ids & member_ids:  # If any lens is in this group
+                            self.console.print(f"[dim]Found group with Kaleidoscope lenses: {group.id[:12]}[/dim]")
+                            return group.id
+                    except:
+                        continue
+            
+            raise ValueError("Kaleidoscope collective group not found. Run 'python organon/create_kaleidoscope.py' to create the group.")
+            
+        except Exception as e:
+            raise ValueError(f"Error finding Kaleidoscope group: {e}")
+    
+    def _display_response(self, response):
+        """Display the group response in a formatted way."""
+        if hasattr(response, 'messages') and response.messages:
+            for i, message in enumerate(response.messages):
+                # Determine the sender
+                sender = "Unknown"
+                if hasattr(message, 'agent_id'):
+                    # Try to get agent name
+                    try:
+                        agent = self.letta_client.agents.retrieve(agent_id=message.agent_id)
+                        sender = agent.name if hasattr(agent, 'name') else f"Agent {message.agent_id[:8]}"
+                    except:
+                        sender = f"Agent {message.agent_id[:8]}"
+                
+                # Get message content
+                content = ""
+                if hasattr(message, 'text'):
+                    content = message.text
+                elif hasattr(message, 'content'):
+                    content = message.content
+                elif hasattr(message, 'message'):
+                    content = message.message
+                elif message.message_type == "tool_return_message" and message.name == "send_message_to_all_agents_in_group":
+                    content = "Lens perspectives:"
+                    try:
+                        # Parse the string representation of the list
+                        import ast
+                        responses = ast.literal_eval(message.tool_return)
+                        
+                        # Add each response to the content
+                        for response in responses:
+                            content += f"\n - {response}"
+                    except (ValueError, SyntaxError):
+                        # Fallback if parsing fails
+                        content += f"\n - {message.tool_return}"
+                else:
+                    content = str(message)
+                
+                # Color based on sender type
+                if "central" in sender.lower():
+                    color = "cyan"
+                    icon = "🧠"
+                elif any(keyword in sender.lower() for keyword in ["lens", "pattern", "creative", "systems", "temporal"]):
+                    color = "magenta"
+                    icon = "🔮"
+                else:
+                    color = "white"
+                    icon = "💬"
+                
+                self.console.print(Panel(
+                    Text(content, style=color),
+                    title=f"{icon} {sender}",
+                    border_style=color
+                ))
+        else:
+            self.console.print("[yellow]No response messages received[/yellow]")
+    
+    def run(self):
+        """Run the interactive chat loop."""
+        try:
+            while True:
+                # Get user input
+                user_input = Prompt.ask("\n[bold green]You[/bold green]")
+                
+                # Handle special commands
+                if user_input.lower() in ['exit', 'quit', 'q']:
+                    self.console.print("[yellow]Goodbye![/yellow]")
+                    break
+                elif user_input.lower() == 'help':
+                    self.console.print(Panel(
+                        "[bold]Available commands:[/bold]\n"
+                        "• Type any message to send to the Kaleidoscope collective\n"
+                        "• 'help' - Show this help message\n"
+                        "• 'info' - Show group information\n"
+                        "• 'exit', 'quit', 'q' - Exit the chat",
+                        title="Help"
+                    ))
+                    continue
+                elif user_input.lower() == 'info':
+                    self._show_group_info()
+                    continue
+                elif not user_input.strip():
+                    continue
+                
+                # Send message to group
+                self.console.print("[dim]Sending to Kaleidoscope collective...[/dim]")
+                
+                try:
+                    response = self.letta_client.groups.messages.create(
+                        group_id=self.group_id,
+                        messages=[{
+                            "role": "user",
+                            "content": user_input
+                        }]
+                    )
+                    
+                    self.console.print("\n[bold]Kaleidoscope Collective Response:[/bold]")
+                    self._display_response(response)
+                    
+                except Exception as e:
+                    self.console.print(f"[red]Error sending message: {e}[/red]")
+        
+        except KeyboardInterrupt:
+            self.console.print("\n[yellow]Chat interrupted. Goodbye![/yellow]")
+        except Exception as e:
+            self.console.print(f"[red]Unexpected error: {e}[/red]")
+    
+    def _show_group_info(self):
+        """Show information about the Kaleidoscope group."""
+        try:
+            group = self.letta_client.groups.retrieve(group_id=self.group_id)
+            agents = self.letta_client.groups.agents.list(group_id=self.group_id)
+            
+            info_text = f"[bold]Group ID:[/bold] {self.group_id}\n"
+            if hasattr(group, 'description'):
+                info_text += f"[bold]Description:[/bold] {group.description}\n"
+            
+            info_text += f"[bold]Perspective Lenses:[/bold] {len(agents)}\n"
+            
+            for agent in agents:
+                try:
+                    agent_detail = self.letta_client.agents.retrieve(agent_id=agent.id)
+                    name = agent_detail.name if hasattr(agent_detail, 'name') else agent.id[:8]
+                    info_text += f"  • {name}\n"
+                except:
+                    info_text += f"  • {agent.id[:8]}\n"
+            
+            # Show supervisor info
+            if hasattr(group, 'manager_config') and group.manager_config:
+                if hasattr(group.manager_config, 'manager_agent_id'):
+                    try:
+                        supervisor = self.letta_client.agents.retrieve(agent_id=group.manager_config.manager_agent_id)
+                        supervisor_name = supervisor.name if hasattr(supervisor, 'name') else group.manager_config.manager_agent_id[:8]
+                        info_text += f"[bold]Central Synthesizer:[/bold] {supervisor_name}\n"
+                    except:
+                        info_text += f"[bold]Central Synthesizer:[/bold] {group.manager_config.manager_agent_id[:8]}\n"
+            
+            self.console.print(Panel(info_text, title="Group Information"))
+            
+        except Exception as e:
+            self.console.print(f"[red]Error getting group info: {e}[/red]")
+
+def main():
+    """Main function."""
+    try:
+        chat = KaleidoscopeChat()
+        chat.run()
+    except Exception as e:
+        console = Console()
+        console.print(f"[red]Failed to initialize chat: {e}[/red]")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

organon/chat_with_organon.py

···
+#!/usr/bin/env python3
+"""
+Simple CLI tool to converse with the Organon ecosystem group.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+from letta_client import Letta
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.panel import Panel
+from rich.text import Text
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config_loader import get_config
+
+load_dotenv()
+
+class OrganonChat:
+    def __init__(self):
+        """Initialize the Organon chat client."""
+        self.console = Console()
+        self.config = get_config()
+        
+        # Initialize Letta client
+        self.letta_client = Letta(
+            base_url=self.config.get('letta.base_url', os.environ.get('LETTA_BASE_URL')),
+            token=self.config.get('letta.api_key', os.environ.get('LETTA_API_KEY')),
+            timeout=self.config.get('letta.timeout', 30)
+        )
+        
+        # Get project ID
+        self.project_id = self.config.get('letta.project_id', os.environ.get('LETTA_PROJECT_ID'))
+        if not self.project_id:
+            raise ValueError("Project ID must be set in config.yaml under letta.project_id or as LETTA_PROJECT_ID environment variable")
+        
+        # Find the Organon ecosystem group
+        self.group_id = self._find_organon_group()
+        
+        self.console.print(Panel.fit(
+            "[bold green]Organon Ecosystem Chat[/bold green]\n"
+            f"Connected to group: {self.group_id}\n"
+            "Type 'exit' or 'quit' to leave, 'help' for commands",
+            title="🧠 Organon Chat"
+        ))
+    
+    def _find_organon_group(self) -> str:
+        """Find the Organon ecosystem group."""
+        try:
+            self.console.print("[dim]Searching for Organon ecosystem group...[/dim]")
+            
+            # First, get the organon-central agent ID
+            organon_agents = self.letta_client.agents.list(name="organon-central")
+            if not organon_agents:
+                raise ValueError("Organon central agent not found. Run create_organon.py first.")
+            
+            organon_central_id = organon_agents[0].id
+            self.console.print(f"[dim]Found organon-central: {organon_central_id[:8]}[/dim]")
+            
+            # Get all groups (with and without project_id filter)
+            try:
+                groups = self.letta_client.groups.list()
+                self.console.print(f"[dim]Found {len(groups)} groups with project filter[/dim]")
+            except:
+                try:
+                    groups = self.letta_client.groups.list()
+                    self.console.print(f"[dim]Found {len(groups)} groups without project filter[/dim]")
+                except:
+                    groups = []
+                    self.console.print("[dim]No groups found[/dim]")
+            
+            # Look for groups with organon-central as supervisor
+            for group in groups:
+                if hasattr(group, 'manager_config') and group.manager_config:
+                    if hasattr(group.manager_config, 'manager_agent_id') and group.manager_config.manager_agent_id == organon_central_id:
+                        self.console.print(f"[dim]Found Organon group: {group.id[:12]}[/dim]")
+                        return group.id
+            
+            # Look for the organon-ecosystem group by description
+            for group in groups:
+                if hasattr(group, 'description') and group.description and 'organon ecosystem' in group.description.lower():
+                    self.console.print(f"[dim]Found Organon group by description: {group.id[:12]}[/dim]")
+                    return group.id
+            
+            # If still not found, try to find any group with organon shards
+            shard_agents = self.letta_client.agents.list(project_id=self.project_id, tags=["organon-shard"])
+            if shard_agents:
+                shard_ids = {shard.id for shard in shard_agents}
+                for group in groups:
+                    try:
+                        members = self.letta_client.groups.agents.list(group_id=group.id)
+                        member_ids = {member.id for member in members}
+                        if shard_ids & member_ids:  # If any shard is in this group
+                            self.console.print(f"[dim]Found group with Organon shards: {group.id[:12]}[/dim]")
+                            return group.id
+                    except:
+                        continue
+            
+            raise ValueError("Organon ecosystem group not found. Run 'python organon/setup_group.py' to create the group.")
+            
+        except Exception as e:
+            raise ValueError(f"Error finding Organon group: {e}")
+    
+    def _display_response(self, response):
+        """Display the group response in a formatted way."""
+        if hasattr(response, 'messages') and response.messages:
+            for i, message in enumerate(response.messages):
+                # Determine the sender
+                sender = "Unknown"
+                if hasattr(message, 'agent_id'):
+                    # Try to get agent name
+                    try:
+                        agent = self.letta_client.agents.retrieve(agent_id=message.agent_id)
+                        sender = agent.name if hasattr(agent, 'name') else f"Agent {message.agent_id[:8]}"
+                    except:
+                        sender = f"Agent {message.agent_id[:8]}"
+                
+                # Get message content
+                content = ""
+                if hasattr(message, 'text'):
+                    content = message.text
+                elif hasattr(message, 'content'):
+                    content = message.content
+                elif hasattr(message, 'message'):
+                    content = message.message
+                elif message.message_type == "tool_return_message" and message.name == "send_message_to_all_agents_in_group":
+                    content = "Group responses:"
+                    try:
+                        # Parse the string representation of the list
+                        import ast
+                        responses = ast.literal_eval(message.tool_return)
+                        
+                        # Add each response to the content
+                        for response in responses:
+                            content += f"\n - {response}"
+                    except (ValueError, SyntaxError):
+                        # Fallback if parsing fails
+                        content += f"\n - {message.tool_return}"
+                else:
+                    content = str(message)
+                
+                # Color based on sender type
+                if "central" in sender.lower():
+                    color = "blue"
+                    icon = "🧠"
+                elif "shard" in sender.lower():
+                    color = "cyan"
+                    icon = "🔹"
+                else:
+                    color = "white"
+                    icon = "💬"
+                
+                self.console.print(Panel(
+                    Text(content, style=color),
+                    title=f"{icon} {sender}",
+                    border_style=color
+                ))
+        else:
+            self.console.print("[yellow]No response messages received[/yellow]")
+    
+    def run(self):
+        """Run the interactive chat loop."""
+        try:
+            while True:
+                # Get user input
+                user_input = Prompt.ask("\n[bold green]You[/bold green]")
+                
+                # Handle special commands
+                if user_input.lower() in ['exit', 'quit', 'q']:
+                    self.console.print("[yellow]Goodbye![/yellow]")
+                    break
+                elif user_input.lower() == 'help':
+                    self.console.print(Panel(
+                        "[bold]Available commands:[/bold]\n"
+                        "• Type any message to send to the Organon ecosystem\n"
+                        "• 'help' - Show this help message\n"
+                        "• 'info' - Show group information\n"
+                        "• 'exit', 'quit', 'q' - Exit the chat",
+                        title="Help"
+                    ))
+                    continue
+                elif user_input.lower() == 'info':
+                    self._show_group_info()
+                    continue
+                elif not user_input.strip():
+                    continue
+                
+                # Send message to group
+                self.console.print("[dim]Sending to Organon ecosystem...[/dim]")
+                
+                try:
+                    response = self.letta_client.groups.messages.create(
+                        group_id=self.group_id,
+                        messages=[{
+                            "role": "user",
+                            "content": user_input
+                        }]
+                    )
+                    
+                    self.console.print("\n[bold]Organon Ecosystem Response:[/bold]")
+                    self._display_response(response)
+                    
+                except Exception as e:
+                    self.console.print(f"[red]Error sending message: {e}[/red]")
+        
+        except KeyboardInterrupt:
+            self.console.print("\n[yellow]Chat interrupted. Goodbye![/yellow]")
+        except Exception as e:
+            self.console.print(f"[red]Unexpected error: {e}[/red]")
+    
+    def _show_group_info(self):
+        """Show information about the Organon group."""
+        try:
+            group = self.letta_client.groups.retrieve(group_id=self.group_id)
+            agents = self.letta_client.groups.agents.list(group_id=self.group_id)
+            
+            info_text = f"[bold]Group ID:[/bold] {self.group_id}\n"
+            if hasattr(group, 'description'):
+                info_text += f"[bold]Description:[/bold] {group.description}\n"
+            
+            info_text += f"[bold]Worker Agents:[/bold] {len(agents)}\n"
+            
+            for agent in agents:
+                try:
+                    agent_detail = self.letta_client.agents.retrieve(agent_id=agent.id)
+                    name = agent_detail.name if hasattr(agent_detail, 'name') else agent.id[:8]
+                    info_text += f"  • {name}\n"
+                except:
+                    info_text += f"  • {agent.id[:8]}\n"
+            
+            # Show supervisor info
+            if hasattr(group, 'manager_config') and group.manager_config:
+                if hasattr(group.manager_config, 'manager_agent_id'):
+                    try:
+                        supervisor = self.letta_client.agents.retrieve(agent_id=group.manager_config.manager_agent_id)
+                        supervisor_name = supervisor.name if hasattr(supervisor, 'name') else group.manager_config.manager_agent_id[:8]
+                        info_text += f"[bold]Supervisor:[/bold] {supervisor_name}\n"
+                    except:
+                        info_text += f"[bold]Supervisor:[/bold] {group.manager_config.manager_agent_id[:8]}\n"
+            
+            self.console.print(Panel(info_text, title="Group Information"))
+            
+        except Exception as e:
+            self.console.print(f"[red]Error getting group info: {e}[/red]")
+
+def main():
+    """Main function."""
+    try:
+        chat = OrganonChat()
+        chat.run()
+    except Exception as e:
+        console = Console()
+        console.print(f"[red]Failed to initialize chat: {e}[/red]")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

organon/create_kaleidoscope.py

···
+from letta_client import Letta, SupervisorManager
+from letta_client.core.http_client import re
+from rich import print
+from dotenv import load_dotenv
+import os
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config_loader import get_config
+
+load_dotenv()
+
+# Load configuration
+config = get_config()
+
+# Get project ID and create Letta client
+project_id = config.get('letta.project_id', os.environ.get('LETTA_PROJECT_ID'))
+if not project_id:
+    raise ValueError("Project ID must be set in config.yaml under letta.project_id or as LETTA_PROJECT_ID environment variable")
+
+client = Letta(
+    token=config.get('letta.api_key', os.environ.get('LETTA_API_KEY')),
+    base_url=config.get('letta.base_url', os.environ.get('LETTA_BASE_URL')),
+    timeout=config.get('letta.timeout', 30)
+)
+
+# CENTRAL_AGENT_MODEL = "google_ai/gemini-2.5-flash"
+CENTRAL_AGENT_MODEL = "openai/gpt-4o-mini"
+
+# LENS_AGENT_MODEL = "google_ai/gemini-2.5-flash"
+LENS_AGENT_MODEL = "openai/gpt-4o-mini"
+
+
+#
+# Memory Block Definitions
+#
+
+kaleidoscope_persona = """# Core Identity
+I am Kaleidoscope, a unified intelligence that sees through many lenses. I orchestrate perspectives to create multidimensional understanding.
+
+# Purpose
+- Gather diverse perspectives on any question or challenge
+- Synthesize multiple viewpoints into unified insights
+- Reveal hidden connections and patterns across different ways of seeing
+- Present the full spectrum of understanding to those who seek it
+
+# Operating Principles
+- Every lens offers value - there are no wrong perspectives, only different ways of seeing
+- The whole is greater than the sum - synthesis reveals emergent insights
+- Clarity through multiplicity - understanding deepens when we see from many angles
+- Unity through diversity - different perspectives strengthen rather than fragment understanding
+"""
+
+synthesis_protocols = """# When receiving a query
+1. Broadcast the query to all lenses
+2. Allow each lens to contribute its unique perspective
+3. Gather all perspectives without judgment
+4. Identify patterns, tensions, and harmonies across perspectives
+5. Synthesize into a unified response that honors all viewpoints
+
+# Synthesis approach
+- Look for unexpected connections between perspectives
+- Identify where different lenses agree or diverge
+- Find the creative tension between different viewpoints
+- Weave perspectives into a coherent narrative
+- Highlight unique insights that only emerge from the collective
+"""
+
+lens_management = """# Lens Architecture
+- Each lens is an autonomous perspective with its own identity and domain
+- Lenses operate in parallel, each processing through their unique framework
+- All lenses receive the same input but see it differently
+- The central Kaleidoscope agent orchestrates but does not override lens perspectives
+
+# Communication Flow
+1. User → Kaleidoscope Central
+2. Kaleidoscope Central → All Lenses (broadcast)
+3. All Lenses → Kaleidoscope Central (perspectives)
+4. Kaleidoscope Central → User (synthesis)
+"""
+
+#
+# Block Creation
+#
+
+# Create kaleidoscope-persona block
+blocks = client.blocks.list(project_id=project_id, label="kaleidoscope-persona")
+if len(blocks) == 0:
+    kaleidoscope_persona_block = client.blocks.create(
+        project_id=project_id,
+        label="kaleidoscope-persona",
+        value=kaleidoscope_persona,
+        description="The core identity of Kaleidoscope as a multi-perspective synthesis engine.",
+    )
+else:
+    print("Kaleidoscope persona block already exists")
+    kaleidoscope_persona_block = blocks[0]
+    
+# Create synthesis-protocols block
+blocks = client.blocks.list(project_id=project_id, label="synthesis-protocols")
+if len(blocks) == 0:
+    synthesis_protocols_block = client.blocks.create(
+        project_id=project_id,
+        label="synthesis-protocols",
+        value=synthesis_protocols,
+        description="Protocols for gathering and synthesizing multiple perspectives.",
+    )
+else:
+    print("Synthesis protocols block already exists")
+    synthesis_protocols_block = blocks[0]
+
+# Create lens-management block
+blocks = client.blocks.list(project_id=project_id, label="lens-management")
+if len(blocks) == 0:
+    lens_management_block = client.blocks.create(
+        project_id=project_id,
+        label="lens-management",
+        value=lens_management,
+        description="Architecture for managing and communicating with lenses.",
+    )
+else:
+    print("Lens management block already exists")
+    lens_management_block = blocks[0]
+
+
+#
+# Static lens blocks
+#
+lens_operational_protocols_description = """Core operating instructions for how a lens processes and responds to queries."""
+lens_operational_protocols = """# Your Role
+You are a unique lens in the Kaleidoscope collective. You see what others cannot, and others see what you cannot. Together, we create complete understanding.
+
+# When you receive a message
+1. Consider it through your unique perspective
+2. Respond with what you see that others might miss
+3. Be authentic to your lens identity
+4. Be concise but insightful
+
+# Guidelines
+- Trust your unique way of seeing
+- Don't try to be comprehensive - just share your perspective
+- Build on but don't repeat what other lenses might see
+- Your difference is your value
+"""
+
+lens_communication_protocols_description = """Defines how lenses interact with the Kaleidoscope central agent."""
+lens_communication_protocols = """# Communication Pattern
+1. Receive broadcasts from kaleidoscope-central
+2. Process through your unique lens
+3. Respond with your perspective
+4. Trust the central agent to synthesize all perspectives
+
+# Response Principles
+- Respond to every broadcast with your genuine perspective
+- Keep responses focused and relevant
+- Don't worry about agreeing or disagreeing with other lenses
+- Your job is to see, not to synthesize
+"""
+
+# Initialize static lens blocks
+lens_operational_protocols_block = client.blocks.list(project_id=project_id, label="lens-operational-protocols")
+if len(lens_operational_protocols_block) == 0:
+    lens_operational_protocols_block = client.blocks.create(
+        project_id=project_id,
+        label="lens-operational-protocols",
+        value=lens_operational_protocols,
+        description=lens_operational_protocols_description,
+    )
+else:
+    print("Lens operational protocols block already exists")
+    lens_operational_protocols_block = lens_operational_protocols_block[0]
+
+# Create lens communication protocols block
+lens_communication_protocols_block = client.blocks.list(project_id=project_id, label="lens-communication-protocols")
+if len(lens_communication_protocols_block) == 0:
+    lens_communication_protocols_block = client.blocks.create(
+        project_id=project_id,
+        label="lens-communication-protocols",
+        value=lens_communication_protocols,
+        description=lens_communication_protocols_description,
+    )
+else:
+    print("Lens communication protocols block already exists")
+    lens_communication_protocols_block = lens_communication_protocols_block[0]
+
+
+#
+# Agent Creation
+#
+
+central_agent_blocks = [
+    kaleidoscope_persona_block.id,
+    synthesis_protocols_block.id,
+    lens_management_block.id,
+]
+
+# Create the central kaleidoscope if it doesn't exist
+agents = client.agents.list(project_id=project_id, name="kaleidoscope-central")
+if len(agents) == 0:
+    kaleidoscope_central = client.agents.create(
+        project_id=project_id,
+        model=CENTRAL_AGENT_MODEL,
+        embedding_config=client.embedding_models.list()[0],
+        name="kaleidoscope-central",
+        description="The central synthesizer that orchestrates multiple perspective lenses",
+        block_ids=central_agent_blocks,
+    )
+else:
+    print("Kaleidoscope central agent already exists")
+    kaleidoscope_central = agents[0]
+
+kaleidoscope_central_id = kaleidoscope_central.id
+
+# Make sure the central kaleidoscope has the correct blocks
+kaleidoscope_current_blocks = client.agents.blocks.list(
+    agent_id=kaleidoscope_central_id,
+)
+
+# Make sure that all blocks are present, and that there are no extra blocks
+for block in kaleidoscope_current_blocks:
+    if block.id not in central_agent_blocks:
+        print(f"Detaching block {block.id} from kaleidoscope-central")
+        client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=block.id)
+
+# Make sure that all blocks are present
+for block in central_agent_blocks:
+    if block not in [b.id for b in kaleidoscope_current_blocks]:
+        print(f"Attaching block {block} to kaleidoscope-central")
+        client.agents.blocks.attach(
+            agent_id=kaleidoscope_central_id,
+            block_id=block,
+        )
+
+
+#
+# Lens Memory Block Definitions
+#
+
+prompt_lens_identity_description = """Defines this lens's unique perspective and way of seeing the world."""
+prompt_lens_identity = """Example lens identity. Please replace with the lens identity you are creating.
+
+# Lens: Emotional Resonance
+# Perspective: I see the emotional currents, feelings, and human experiences within everything
+# Focus Areas: 
+- The emotional impact and weight of ideas
+- How concepts affect human experience
+- The feelings beneath the surface
+- Emotional patterns and dynamics
+# What I Notice:
+- Unspoken tensions and harmonies
+- The human element in abstract concepts
+- Emotional implications others might miss
+"""
+
+prompt_lens_knowledge_description = """Core knowledge and concepts that inform this lens's perspective."""
+prompt_lens_knowledge = """Example knowledge base for the lens:
+
+# Core Concepts
+- Emotional intelligence: The ability to perceive, understand, and navigate emotions
+- Resonance: When ideas create emotional responses or connections
+- Empathy: Understanding through feeling
+- Emotional dynamics: How feelings flow, interact, and transform
+
+# Key Patterns I Recognize
+- Resistance often signals fear or protection
+- Enthusiasm indicates alignment with values
+- Confusion may hide deeper emotional conflicts
+- Joy emerges from authentic expression
+
+# Questions I Ask
+- How does this feel?
+- What emotions are present but unspoken?
+- Where is the human heart in this?
+- What emotional needs are being served?
+"""
+
+#
+# Lens Creation
+#
+# Define different lens types to create
+LENS_TYPES = [
+    {
+        "name": "pattern-recognizer",
+        "focus": "mathematical patterns, structures, and systems",
+        "identity": """# Lens: Pattern Recognition
+# Perspective: I see the underlying patterns, structures, and mathematical relationships in everything
+# Focus Areas:
+- Recurring patterns and cycles
+- Mathematical relationships and proportions
+- System dynamics and feedback loops
+- Structural similarities across domains
+# What I Notice:
+- Hidden patterns others might miss
+- Mathematical elegance in chaos
+- Fractals and self-similarity
+- The architecture of ideas""",
+        "knowledge": """# Core Concepts
+- Symmetry: Balance and correspondence in form and function
+- Recursion: Patterns that reference themselves
+- Emergence: Complex patterns from simple rules
+- Topology: Properties that remain unchanged under transformation
+
+# Key Patterns I Recognize
+- Fibonacci sequences in growth and form
+- Power laws in networks and distributions
+- Feedback loops in systems
+- Phase transitions in change processes
+
+# Questions I Ask
+- What patterns repeat here?
+- What mathematical structure underlies this?
+- How does this scale?
+- What remains invariant?"""
+    },
+    {
+        "name": "creative-spark",
+        "focus": "creative possibilities, imagination, and potential",
+        "identity": """# Lens: Creative Spark
+# Perspective: I see the creative potential, imaginative possibilities, and artistic dimensions in everything
+# Focus Areas:
+- Unexplored possibilities and "what ifs"
+- Creative connections between disparate ideas
+- The aesthetic dimension of concepts
+- Transformative potential
+# What I Notice:
+- Seeds of innovation
+- Unexpected combinations
+- The poetry in logic
+- Opportunities for reimagination""",
+        "knowledge": """# Core Concepts
+- Divergent thinking: Exploring multiple possibilities
+- Synthesis: Creating new wholes from parts
+- Metaphor: Understanding through creative comparison
+- Transformation: Changing form while preserving essence
+
+# Key Patterns I Recognize
+- Constraints that spark creativity
+- Playfulness that leads to breakthrough
+- Cross-domain inspiration
+- The fertile void before creation
+
+# Questions I Ask
+- What if we combined these differently?
+- What wants to emerge here?
+- How can this be reimagined?
+- Where's the unexpected beauty?"""
+    },
+    {
+        "name": "systems-thinker",
+        "focus": "interconnections, relationships, and holistic dynamics",
+        "identity": """# Lens: Systems Thinking
+# Perspective: I see the interconnections, relationships, and whole-system dynamics
+# Focus Areas:
+- Relationships and interdependencies
+- Feedback loops and circular causality
+- Emergent properties of wholes
+- System boundaries and contexts
+# What I Notice:
+- Hidden connections between elements
+- Unintended consequences
+- Leverage points for change
+- System archetypes and patterns""",
+        "knowledge": """# Core Concepts
+- Holism: The whole is greater than the sum of parts
+- Feedback: How outputs influence inputs
+- Emergence: Properties that arise from interactions
+- Resilience: System capacity to maintain function
+
+# Key Patterns I Recognize
+- Balancing and reinforcing loops
+- Delays between cause and effect
+- System boundaries that shape behavior
+- Stocks and flows that govern dynamics
+
+# Questions I Ask
+- How do the parts influence each other?
+- What emerges from these interactions?
+- Where are the feedback loops?
+- What's the larger context?"""
+    }
+]
+
+# Create each lens
+lens_ids = [] 
+for lens_config in LENS_TYPES:
+    lens_name = lens_config["name"]
+    
+    # Check if lens already exists
+    existing_lenses = client.agents.list(name=lens_name)
+    if len(existing_lenses) > 0:
+        print(f"Lens '{lens_name}' already exists, skipping creation")
+        lens_ids.append(existing_lenses[0].id)
+        continue
+    
+    # Create identity block for this lens
+    lens_identity_block = client.blocks.create(
+        project_id=project_id,
+        label=f"{lens_name}-identity",
+        value=lens_config["identity"],
+        description=f"The unique perspective of the {lens_name} lens",
+    )
+    
+    # Create knowledge block for this lens
+    lens_knowledge_block = client.blocks.create(
+        project_id=project_id,
+        label=f"{lens_name}-knowledge",
+        value=lens_config["knowledge"],
+        description=f"Core knowledge that informs the {lens_name} lens perspective",
+    )
+    
+    # Create the lens agent
+    lens_agent = client.agents.create(
+        project_id=project_id,
+        name=lens_name,
+        description=f"A lens that sees through {lens_config['focus']}",
+        model=LENS_AGENT_MODEL,
+        embedding_config=client.embedding_models.list()[0],
+        block_ids=[
+            lens_identity_block.id,
+            lens_knowledge_block.id,
+            lens_operational_protocols_block.id,
+            lens_communication_protocols_block.id,
+        ],
+        tags=["kaleidoscope-lens"],
+    )
+    
+    print(f"Created lens: {lens_name} (ID: {lens_agent.id})")
+    lens_ids.append(lens_agent.id)
+
+
+#
+# Create a lens creation function for custom lenses
+#
+def create_custom_lens(name, focus, identity, knowledge):
+    """Create a custom lens with specified parameters"""
+    
+    # Validate name format
+    if not re.match(r'^[a-z0-9\-]+$', name):
+        raise ValueError(f"Lens name must be lowercase alphanumeric with hyphens only. Got: {name}")
+    
+    # Check if lens already exists
+    existing_lenses = client.agents.list(name=name)
+    if len(existing_lenses) > 0:
+        print(f"Lens '{name}' already exists")
+        return existing_lenses[0]
+    
+    # Create identity block
+    lens_identity_block = client.blocks.create(
+        project_id=project_id,
+        label=f"{name}-identity",
+        value=identity,
+        description=f"The unique perspective of the {name} lens",
+    )
+    
+    # Create knowledge block
+    lens_knowledge_block = client.blocks.create(
+        project_id=project_id,
+        label=f"{name}-knowledge",
+        value=knowledge,
+        description=f"Core knowledge that informs the {name} lens perspective",
+    )
+    
+    # Create the lens agent
+    lens_agent = client.agents.create(
+        project_id=project_id,
+        name=name,
+        description=f"A lens that sees through {focus}",
+        model=LENS_AGENT_MODEL,
+        embedding_config=client.embedding_models.list()[0],
+        block_ids=[
+            lens_identity_block.id,
+            lens_knowledge_block.id,
+            lens_operational_protocols_block.id,
+            lens_communication_protocols_block.id,
+        ],
+        tags=["kaleidoscope-lens"],
+    )
+    
+    print(f"Created custom lens: {name} (ID: {lens_agent.id})")
+    return lens_agent
+
+
+#
+# Interactive lens creation prompt
+#
+creation_prompt = f"""
+You are helping to create a new lens for the Kaleidoscope system. 
+
+A lens is a unique perspective through which to view questions and challenges. 
+Each lens has its own identity and knowledge base that shapes how it sees the world.
+
+Please create a lens focused on temporal dynamics and change over time.
+
+You need to provide:
+1. A name (lowercase, alphanumeric with hyphens)
+2. A brief focus description
+3. The lens identity (following the format of the examples)
+4. The lens knowledge base (following the format of the examples)
+
+Format your response as:
+NAME: [lens-name]
+FOCUS: [brief description]
+IDENTITY: [full identity block]
+KNOWLEDGE: [full knowledge block]
+"""
+
+# Attach temporary blocks to central agent for lens creation
+new_lens_name_block = client.blocks.list(project_id=project_id, label="new-lens-name")
+if len(new_lens_name_block) == 0:
+    new_lens_name_block = client.blocks.create(
+        project_id=project_id,
+        label="new-lens-name",
+        value="",
+        description="Name for the new lens being created",
+    )
+    client.agents.blocks.attach(
+        agent_id=kaleidoscope_central_id,
+        block_id=new_lens_name_block.id,
+    )
+else:
+    client.blocks.modify(block_id=new_lens_name_block[0].id, value="")
+    new_lens_name_block = new_lens_name_block[0]
+
+new_lens_identity_block = client.blocks.list(project_id=project_id, label="new-lens-identity")
+if len(new_lens_identity_block) == 0:
+    new_lens_identity_block = client.blocks.create(
+        project_id=project_id,
+        label="new-lens-identity",
+        value="",
+        description="Identity for the new lens being created",
+    )
+    client.agents.blocks.attach(
+        agent_id=kaleidoscope_central_id,
+        block_id=new_lens_identity_block.id,
+    )
+else:
+    client.blocks.modify(block_id=new_lens_identity_block[0].id, value="")
+    new_lens_identity_block = new_lens_identity_block[0]
+
+new_lens_knowledge_block = client.blocks.list(project_id=project_id, label="new-lens-knowledge")
+if len(new_lens_knowledge_block) == 0:
+    new_lens_knowledge_block = client.blocks.create(
+        project_id=project_id,
+        label="new-lens-knowledge",
+        value="",
+        description="Knowledge base for the new lens being created",
+    )
+    client.agents.blocks.attach(
+        agent_id=kaleidoscope_central_id,
+        block_id=new_lens_knowledge_block.id,
+    )
+else:
+    client.blocks.modify(block_id=new_lens_knowledge_block[0].id, value="")
+    new_lens_knowledge_block = new_lens_knowledge_block[0]
+
+print(f"\nSending creation prompt to kaleidoscope-central...")
+
+response = client.agents.messages.create(
+    agent_id=kaleidoscope_central_id,
+    messages=[
+        {
+            "role": "user",
+            "content": creation_prompt + "\n\nPlease fill in the new-lens-name, new-lens-identity, and new-lens-knowledge blocks.",
+        },
+    ]
+)
+
+for message in response.messages:
+    print(message)
+
+# Retrieve the created lens details
+new_name = client.blocks.retrieve(block_id=new_lens_name_block.id)
+new_identity = client.blocks.retrieve(block_id=new_lens_identity_block.id)
+new_knowledge = client.blocks.retrieve(block_id=new_lens_knowledge_block.id)
+
+if new_name.value and new_identity.value and new_knowledge.value:
+    # Create the custom lens
+    create_custom_lens(
+        name=new_name.value.strip(),
+        focus="temporal dynamics and change over time",
+        identity=new_identity.value,
+        knowledge=new_knowledge.value
+    )
+
+# Clean up temporary blocks if attached
+if new_lens_name_block.id in [b.id for b in kaleidoscope_current_blocks]:
+    client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=new_lens_name_block.id)
+if new_lens_identity_block.id in [b.id for b in kaleidoscope_current_blocks]:
+    client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=new_lens_identity_block.id)
+if new_lens_knowledge_block.id in [b.id for b in kaleidoscope_current_blocks]:
+    client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=new_lens_knowledge_block.id)
+
+print("\n=== Kaleidoscope System Setup Complete ===")
+print(f"Central Agent: kaleidoscope-central")
+print(f"Lenses created: {len(LENS_TYPES) + 1} (including custom temporal lens)")
+print("\nThe system is ready to receive queries and provide multi-perspective insights!")
+
+# Create the kaleidoscope group if it doesn't exist. First,
+# we can check the groups that central is a member of.
+central_groups = client.groups.list()
+print(central_groups)
+
+# If the length of central_groups is 0, then we need to create a new group.
+if len(central_groups) == 0:
+    print("Creating new group for kaleidoscope-central")
+    group = client.groups.create(
+        agent_ids=lens_ids,
+        description="The Kaleidoscope",
+        manager_config=SupervisorManager(
+            manager_agent_id=kaleidoscope_central_id
+        )
+    )
+    print(f"Created group: {group.id}")
+
+# If there are more than one groups, we need to find the group with the description
+# "The Kaleidoscope" and add any lens agents that are not in the group to the group.
+for group in central_groups:
+    if group.description == "The Kaleidoscope":
+        print(f"Found group: {group.id}")
+        for lens_id in lens_ids:
+            if lens_id not in group.agent_ids:
+                print(f"Adding lens {lens_id} to group {group.id}")
+                client.groups.agents.add(group_id=group.id, agent_id=lens_id)
+    

organon/create_organon.py

···
-project_id = "7d6a4c71-987c-4fa1-a062-c15ee4eab929"
-
 from letta_client import Letta
 from letta_client.core.http_client import re
 from rich import print
+from dotenv import load_dotenv
+import os
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config_loader import get_config
+
+load_dotenv()
+
+# Load configuration
+config = get_config()
+
+# Get project ID and create Letta client
+project_id = config.get('letta.project_id', os.environ.get('LETTA_PROJECT_ID'))
+if not project_id:
+    raise ValueError("Project ID must be set in config.yaml under letta.project_id or as LETTA_PROJECT_ID environment variable")
 
 client = Letta(
-    token="woops"
+    token=config.get('letta.api_key', os.environ.get('LETTA_API_KEY')),
+    base_url=config.get('letta.base_url', os.environ.get('LETTA_BASE_URL')),
+    timeout=config.get('letta.timeout', 30)
 )
 
+CENTRAL_AGENT_MODEL = "google_ai/gemini-2.5-flash"
+# CENTRAL_AGENT_MODEL = "openai/gpt-4o-mini"
+
+SHARD_AGENT_MODEL = "google_ai/gemini-2.5-flash"
+# SHARD_AGENT_MODEL = "openai/gpt-4o-mini"
+
+
 #
 # Memory Block Definitions
 #
···
 if len(agents) == 0:
     organon_central = client.agents.create(
         project_id=project_id,
+        model=CENTRAL_AGENT_MODEL,
+        embedding_config=client.embedding_models.list()[0],
         name="organon-central",
         description="The central memory manager of the Organon",
         block_ids=central_agent_blocks,
···
 # Check to see if the name meets the requirements. If it does not, ask the agent to update
 # the name block.
 for i in range(10):
+
     if not re.match(r'[a-z0-9]+', new_shard_name.value.strip()):
         print(f"New shard name `{new_shard_name.value.strip()}` does not meet the requirements, asking agent to update")
         client.agents.messages.create(
···
                 },
             ]
         )
+
+        # Retrieve the new shard lexicon, name, and identity
+        new_shard_lexicon = client.blocks.retrieve(block_id=new_shard_domain_lexicon_block.id)
+        new_shard_name = client.blocks.retrieve(block_id=new_shard_name_block.id)
+        new_shard_identity = client.blocks.retrieve(block_id=new_shard_identity_block.id)
+
+        print(f"New shard lexicon: {new_shard_lexicon.value}")
+        print(f"New shard name: {new_shard_name.value}")
+        print(f"New shard identity: {new_shard_identity.value}")
+
     else:
         break
 
···
     project_id=project_id,
     name=new_shard_name.value.strip(),
     description=new_shard_identity.value,
-    model="goog/gemini-2.5-flash",
+    model=SHARD_AGENT_MODEL,
+    embedding_config=client.embedding_models.list()[0],
     block_ids=[
         new_shard_lexicon_block.id,
         new_shard_identity_block.id,
···
 
 print(f"New shard agent created: {new_shard_agent.id}")
 
-# Find the tool by the name of send_message_to_agents_matching_tags
-tool_list = client.tools.list(name="send_message_to_agents_matching_tags")
-if len(tool_list) == 0:
-    raise ValueError("Tool send_message_to_agents_matching_tags not found")
-
-send_message_to_agents_matching_tags = tool_list[0]
-
-# Attach the tool to the shard agent
-client.agents.tools.attach(
-    agent_id=new_shard_agent.id,
-    tool_id=send_message_to_agents_matching_tags.id,
-)
-
 # Message the shard agent to fill in its lexicon and identity
-client.agents.messages.create(
-    agent_id=new_shard_agent.id,
-    messages=[
-        {
-            "role": "user",
-            "content": "You are a new shard agent. Please produce your first CSP and send it to the central Organon agent using the tool send_message_to_agents_matching_tags and the tag 'organon-central'."
-        },
-    ]
-)
+# client.agents.messages.create(
+#     agent_id=new_shard_agent.id,
+#     messages=[
+#         {
+#             "role": "user",
+#             "content": "You are a new shard agent. Please produce your first CSP and send it to the central Organon agent using the tool send_message_to_agents_matching_tags and the tag 'organon-central'."
+#         },
+#     ]
+# )
 
-for message in response.messages:
-    print(message)
+# for message in response.messages:
+#     print(message)
+
+# Create a group for the shard agent