flock-core 0.5.0b58__tar.gz → 0.5.0b59__tar.gz

{flock_core-0.5.0b58 → flock_core-0.5.0b59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.5.0b58
+Version: 0.5.0b59
 Summary: Add your description here
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 
 > **Stop engineering prompts. Start declaring contracts.**
 
-Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**, proven patterns from distributed systems, decades of engaging with micro-service landscapes and classical AI, now applied to modern LLMs.
+Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**—proven patterns from distributed systems, decades of experience with microservice architectures, and classical AI—now applied to modern LLMs.
 
 
 
@@ -62,8 +62,8 @@ prompt = """You are an expert code reviewer. When you receive code, you should..
 
 # 500-line prompt that breaks when models update
 
-# How do I know that there isn't an even better prompt (you don't)
-# -> proof of 'best possible performane' impossible
+# How do I know that there isn't an even better prompt? (you don't)
+# -> proving 'best possible performance' is impossible
 ```
 
 **🧪 Testing Nightmares**
@@ -90,12 +90,12 @@ workflow.add_edge("agent_b", "agent_c")
 ```python
 # One orchestrator needs domain knowledge of 20+ agents to route correctly
 # Orchestrator 'guesses' next agent based on a natural language description.
-# Hardly fit for critical systems.
+# Not suitable for critical systems.
 ```
 
 These aren't framework limitations, they're **architectural choices** that don't scale.
 
-Most issues are solvable, because decades of experience with micro services taught us hard lessons about decoupling, orchestration and reliability already. Let's use these learnings!
+These challenges are solvable—decades of experience with microservices have taught us hard lessons about decoupling, orchestration, and reliability. Let's apply those lessons!
 
 ---
 
@@ -205,7 +205,7 @@ performance = flock.agent("perf").consumes(Scan).publishes(PerfAnalysis)
 - ✅ **Loose coupling** - Agents don't know about each other, just data types
 - ✅ **Scalable** - O(n) complexity, not O(n²) edges
 
-**This is not a new idea.** Blackboard architecture powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
+**This is not a new idea.** Blackboard architecture has powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
 
 ---
 
@@ -627,7 +627,7 @@ Flock uses a fundamentally different coordination pattern than most multi-agent
 ### What Works Today (v0.5.0)
 
 **✅ Production-ready core:**
-- more than 700 tests, with >75% coverage (>90% on critical paths)
+- More than 700 tests, with >75% coverage (>90% on critical paths)
 - Blackboard orchestrator with typed artifacts
 - Parallel + sequential execution (automatic)
 - Zero-trust security (5 visibility types)
@@ -673,7 +673,7 @@ We're not building a toy framework. We're building enterprise infrastructure for
 
 ### Flock 1.0 - Q4 2025 Release
 
-**We're confident to deliver all enterprise features by Q4 2025:**
+**We're confident we can deliver all enterprise features by Q4 2025:**
 
 **🏢 Enterprise Persistence**
 - Redis and PostgreSQL backends for durable blackboard state

{flock_core-0.5.0b58 → flock_core-0.5.0b59}/README.md

@@ -14,7 +14,7 @@
 
 > **Stop engineering prompts. Start declaring contracts.**
 
-Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**, proven patterns from distributed systems, decades of engaging with micro-service landscapes and classical AI, now applied to modern LLMs.
+Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**—proven patterns from distributed systems, decades of experience with microservice architectures, and classical AI—now applied to modern LLMs.
 
 
 
@@ -32,8 +32,8 @@ prompt = """You are an expert code reviewer. When you receive code, you should..
 
 # 500-line prompt that breaks when models update
 
-# How do I know that there isn't an even better prompt (you don't)
-# -> proof of 'best possible performane' impossible
+# How do I know that there isn't an even better prompt? (you don't)
+# -> proving 'best possible performance' is impossible
 ```
 
 **🧪 Testing Nightmares**
@@ -60,12 +60,12 @@ workflow.add_edge("agent_b", "agent_c")
 ```python
 # One orchestrator needs domain knowledge of 20+ agents to route correctly
 # Orchestrator 'guesses' next agent based on a natural language description.
-# Hardly fit for critical systems.
+# Not suitable for critical systems.
 ```
 
 These aren't framework limitations, they're **architectural choices** that don't scale.
 
-Most issues are solvable, because decades of experience with micro services taught us hard lessons about decoupling, orchestration and reliability already. Let's use these learnings!
+These challenges are solvable—decades of experience with microservices have taught us hard lessons about decoupling, orchestration, and reliability. Let's apply those lessons!
 
 ---
 
@@ -175,7 +175,7 @@ performance = flock.agent("perf").consumes(Scan).publishes(PerfAnalysis)
 - ✅ **Loose coupling** - Agents don't know about each other, just data types
 - ✅ **Scalable** - O(n) complexity, not O(n²) edges
 
-**This is not a new idea.** Blackboard architecture powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
+**This is not a new idea.** Blackboard architecture has powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
 
 ---
 
@@ -597,7 +597,7 @@ Flock uses a fundamentally different coordination pattern than most multi-agent
 ### What Works Today (v0.5.0)
 
 **✅ Production-ready core:**
-- more than 700 tests, with >75% coverage (>90% on critical paths)
+- More than 700 tests, with >75% coverage (>90% on critical paths)
 - Blackboard orchestrator with typed artifacts
 - Parallel + sequential execution (automatic)
 - Zero-trust security (5 visibility types)
@@ -643,7 +643,7 @@ We're not building a toy framework. We're building enterprise infrastructure for
 
 ### Flock 1.0 - Q4 2025 Release
 
-**We're confident to deliver all enterprise features by Q4 2025:**
+**We're confident we can deliver all enterprise features by Q4 2025:**
 
 **🏢 Enterprise Persistence**
 - Redis and PostgreSQL backends for durable blackboard state

flock_core-0.5.0b59/examples/03-the-dashboard/03-scale-test-100-agents.py

@@ -0,0 +1,130 @@
+"""
+Scale Test: 100 Agents Dashboard
+==================================
+This example creates 100 agents to test dashboard UI performance and layout algorithms
+with a large number of nodes. Perfect for stress-testing the visualization system.
+
+How to use:
+1. Run this script: `uv run examples/03-the-dashboard/03-scale-test-100-agents.py`
+2. Open http://localhost:8000 in your browser
+3. Right-click canvas → Auto Layout → Try different layout algorithms:
+   - Hierarchical (Vertical/Horizontal) - See how Dagre handles 100 nodes
+   - Circular - 100 nodes in a perfect circle
+   - Grid - 10x10 grid of agents
+   - Random - Stress test collision detection
+
+Expected behavior:
+- 100 agent nodes in the graph
+- Each agent consumes output from the previous agent (chain pattern)
+- Click "Show Controls" and publish a Signal to trigger the chain
+- Watch the cascade of activations across all 100 agents
+
+Performance expectations:
+- Layout algorithms should complete in <500ms
+- Graph should remain interactive with pan/zoom
+- WebSocket updates should handle 100+ nodes smoothly
+
+Use cases:
+- Test layout algorithm performance with large graphs
+- Verify UI remains responsive with many nodes
+- Validate WebSocket streaming with high node counts
+- Test context menu and interactions with crowded canvas
+"""
+
+import asyncio
+
+from pydantic import BaseModel
+
+from flock.orchestrator import Flock
+from flock.registry import flock_type
+
+
+# Simple signal artifact that gets passed through the chain
+@flock_type
+class Signal(BaseModel):
+    value: int
+    hop: int  # Track how many agents this signal has passed through
+
+
+# Create orchestrator
+flock = Flock("openai/gpt-4.1")
+
+# Create 100 agents in a chain
+# Agent 0 consumes Signal(hop=0)
+# Agent 1 consumes output from Agent 0 and produces Signal(hop=1)
+# Agent 2 consumes output from Agent 1 and produces Signal(hop=2)
+# ... and so on
+print("Creating 100 agents...")
+
+for i in range(100):
+    agent_name = f"agent_{i:03d}"  # agent_000, agent_001, etc.
+
+    # Create a unique type for this agent's output
+    # This allows us to chain agents: agent_0 -> agent_1 -> agent_2 -> ...
+    output_type_name = f"Signal{i:03d}"
+
+    # Dynamically create the output type
+    output_type = type(
+        output_type_name,
+        (Signal,),
+        {
+            "__module__": __name__,
+            "__annotations__": {"value": int, "hop": int},
+        },
+    )
+    flock_type(output_type)
+
+    # Determine what this agent consumes
+    if i == 0:
+        # First agent consumes the initial Signal
+        input_type = Signal
+    else:
+        # All other agents consume output from the previous agent
+        prev_output_type_name = f"Signal{i - 1:03d}"
+        input_type = globals().get(prev_output_type_name)
+        if input_type is None:
+            # Create the input type if it doesn't exist
+            input_type = type(
+                prev_output_type_name,
+                (Signal,),
+                {
+                    "__module__": __name__,
+                    "__annotations__": {"value": int, "hop": int},
+                },
+            )
+            flock_type(input_type)
+
+    # Register the output type in globals so subsequent agents can find it
+    globals()[output_type_name] = output_type
+
+    # Create the agent
+    agent = (
+        flock.agent(agent_name)
+        .description(f"Agent {i} in the chain - passes signal to next agent")
+        .consumes(input_type)
+        .publishes(output_type)
+    )
+
+    if (i + 1) % 10 == 0:
+        print(f"  Created {i + 1}/100 agents...")
+
+print("✅ All 100 agents created!")
+print("\n📊 Graph structure:")
+print("  - 100 agent nodes")
+print("  - 99 edges (chain: agent_000 → agent_001 → ... → agent_099)")
+print("  - Total nodes: 100")
+print("\n🎨 Try different layouts:")
+print("  - Hierarchical (Vertical): Long vertical chain")
+print("  - Hierarchical (Horizontal): Long horizontal chain")
+print("  - Circular: Perfect circle of 100 nodes")
+print("  - Grid: 10×10 organized grid")
+print("  - Random: Stress test collision detection")
+print("\n🚀 Starting dashboard...")
+
+
+# Run with dashboard
+async def main():
+    await flock.serve(dashboard=True)
+
+
+asyncio.run(main())

{flock_core-0.5.0b58 → flock_core-0.5.0b59}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.5.0b58"
+version = "0.5.0b59"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{flock_core-0.5.0b58 → flock_core-0.5.0b59}/uv.lock

@@ -970,7 +970,7 @@ wheels = [
 
 [[package]]
 name = "flock-core"
-version = "0.5.0b58"
+version = "0.5.0b59"
 source = { editable = "." }
 dependencies = [
     { name = "devtools" },