Control-Plane Architecture for Agentic AI Systems

Control-Plane Architecture for Agentic AI Systems

A control-plane architecture coordinates tool execution and enforces safety rules in agentic AI systems. The system demonstrated here processes 3 demo queries with dynamic task routing and logging.

Why This Matters

Real-world agentic systems require strict separation between reasoning and execution to prevent errors. The control plane limits tool usage to 4 actions per request, avoiding overload while maintaining modularity. Without such constraints, unbounded tool calls could lead to cascading failures, as seen in the 2012 App Engine outage caused by uncontrolled scaling.

Key Insights

• “Control plane enforces max 4 tools per request to prevent overload” (from code logic)
• “Sagas over ACID for e-commerce” (general principle applicable to distributed workflows)
• “Temporal used by Stripe, Coinbase” (similar tooling for workflow orchestration)

Working Example

import subprocess
import sys
def install_deps():
    deps = ['anthropic', 'numpy', 'scikit-learn']
    for dep in deps:
        subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', dep])
try:
    import anthropic
except ImportError:
    install_deps()
import anthropic
import json
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from dataclasses import dataclass, asdict
from typing import List, Dict, Any, Optional
from datetime import datetime

@dataclass
class Document:
    id: str
    content: str
    metadata: Dict[str, Any]
    embedding: Optional[np.ndarray] = None

class SimpleRAGRetriever:
    def __init__(self):
        self.documents = self._init_knowledge_base()
    
    def _init_knowledge_base(self) -> List[Document]:
        docs = [
            Document("cs101", "Python basics: Variables store data...", {"topic": "python", "level": "beginner"}),
            # ... (truncated for brevity)
        ]
        for i, doc in enumerate(docs):
            doc.embedding = np.random.rand(128)
            doc.embedding[i*20:(i+1)*20] += 2
        return docs
    
    def retrieve(self, query: str, top_k: int = 2) -> List[Document]:
        query_embedding = np.random.rand(128)
        scores = [cosine_similarity([query_embedding], [doc.embedding])[0][0] for doc in self.documents]
        top_indices = np.argsort(scores)[-top_k:][::-1]
        return [self.documents[i] for i in top_indices]

class ControlPlane:
    def __init__(self, tool_registry: ToolRegistry):
        self.tools = tool_registry
        self.safety_rules = {
            "max_tools_per_request": 4,
            "allowed_tools": ["search_knowledge", "assess_understanding", "update_learner_profile", "log_interaction"]
        }
        self.execution_log = []
    
    def execute(self, plan: Dict[str, Any]) -> Dict[str, Any]:
        if not self._validate_request(plan):
            return {"error": "Safety validation failed", "plan": plan}
        action = plan.get("action")
        params = plan.get("parameters", {})
        result = self._route_and_execute(action, params)
        self.execution_log.append({
            "timestamp": datetime.now().isoformat(),
            "plan": plan,
            "result": result
        })
        return {
            "success": True,
            "action": action,
            "result": result,
            "metadata": {
                "execution_count": len(self.execution_log),
                "safety_checks_passed": True
            }
        }
    
    def _validate_request(self, plan: Dict) -> bool:
        action = plan.get("action")
        if action not in self.safety_rules["allowed_tools"]:
            return False
        if len(self.execution_log) >= 100:
            return False
        return True

Practical Applications

• Use Case: TutorAgent for dynamic Q&A with knowledge retrieval and assessments
• Pitfall: Overloading control plane with too many tools per request causes safety validation failures

References:

• https://www.marktechpost.com/2025/11/28/a-coding-guide-to-design-an-agentic-ai-system-using-a-control-plane-architecture-for-safe-modular-and-scalable-tool-driven-reasoning-workflows/

---