Let's Build a Smarter AI Agent: A Guide to the Control-Plane Design Pattern

Have you ever built an AI agent that felt… a little too wild? You give it a set of tools, a goal, and it just kind of runs off, sometimes doing amazing things, and other times, well, going completely off the rails. It can feel like you’ve built a brilliant but unpredictable intern who needs constant supervision.

I’ve been there. It’s a common growing pain when we start building more complex, "agentic" AI systems. We want them to be autonomous, to reason and act on their own, but we also need them to be safe, reliable, and predictable. How do you get the best of both worlds?

Well, I’ve found a really elegant solution that I want to share with you today: the control-plane architecture.

Don't let the fancy name scare you. Think of it like a project manager for your AI. Instead of the AI’s "brain" having direct access to all its tools, it has to go through a manager—the control plane. This manager checks the request, makes sure it's safe and allowed, and then dispatches the right specialist (the tool) for the job. It’s a simple shift in thinking that makes a world of difference.

Today, we're going to build a simple AI tutor using this very pattern. You'll see, step-by-step, how this approach brings order to the chaos and helps you create agents you can actually trust.

First, Let's Give Our AI a Library Card

Before our AI can teach anyone anything, it needs access to information. This is where a Retrieval-Augmented Generation (RAG) system comes in. Again, fancy term, simple idea: we’re just giving our AI a small, private library to look things up in.

For our little AI tutor, we'll set up a mini knowledge base with a few documents on Python, math, and machine learning.

@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]:
        # ... (code to create a list of documents) ...
        # For simplicity, we're faking the embeddings with random numbers
        for i, doc in enumerate(docs):
            doc.embedding = np.random.rand(128) 
        return docs

    def retrieve(self, query: str, top_k: int = 2) -> List[Document]:
        # ... (code to find the most similar documents) ...
        return [self.documents[i] for i in top_indices]

In a real-world app, you’d use a proper embedding model to create meaningful numerical representations of your documents. But for our example, we’re just using random numbers to simulate the process. The key takeaway is that we now have a SimpleRAGRetriever that can take a query (like "what are Python functions?") and pull out the most relevant documents from its knowledge base. Simple, right?

Next, The Toolbox: What Can Our Agent Actually Do?

Okay, so our agent can look things up. What else? This is where we define its "tools." A tool is just a function that the AI can call to perform a specific action. This is one of my favorite parts because you can get really creative here.

We’ll create a ToolRegistry to hold all the capabilities of our AI tutor. Think of it as its utility belt.

class ToolRegistry:
    def __init__(self, retriever: SimpleRAGRetriever):
        self.retriever = retriever
        self.interaction_log = []
        self.user_state = {"level": "beginner", "topics_covered": []}

    def search_knowledge(self, query: str, filters: Optional[Dict] = None) -> Dict:
        # ... uses the retriever to find documents ...

    def assess_understanding(self, topic: str) -> Dict:
        # ... returns a few quiz questions on a topic ...

    def update_learner_profile(self, topic: str, level: str) -> Dict:
        # ... updates the user's profile to track progress ...

    def log_interaction(self, event: str, details: Dict) -> Dict:
        # ... keeps a log of what happened ...

Let's break down what we just gave our AI:

• search_knowledge: This is its library card in action. It uses the retriever we just built.
• assess_understanding: A way to quiz the user to see if they're getting it.
• update_learner_profile: This gives the AI memory. It can remember what you've learned and what your skill level is.
• log_interaction: A simple diary to record every interaction. This is incredibly useful for debugging and understanding the AI's behavior.

See how modular this is? If we want to give our AI a new skill tomorrow, like the ability to generate diagrams, we just add a new tool to the registry. The rest of the system doesn't need to change.

The Project Manager: Putting the "Control" in Control Plane

Now we get to the heart of the system: the ControlPlane. This is the traffic cop, the project manager, the bouncer at the club door. Its job is not to do the work, but to manage the workflow safely and efficiently.

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)
        # ... log the execution ...
        return { "success": True, "result": result }

    def _validate_request(self, plan: Dict) -> bool:
        action = plan.get("action")
        if action not in self.safety_rules["allowed_tools"]:
            return False
        return True

    def _route_and_execute(self, action: str, params: Dict) -> Any:
        # ... finds the right tool in the registry and runs it ...

This class does two critical things:

1. It Validates: Before doing anything, it checks the request against its safety_rules. Is the requested tool on the approved list? Is the agent trying to do too many things at once? This is your first line of defense against unexpected behavior.
2. It Routes: If the request is valid, it looks up the correct function in the ToolRegistry and executes it. It acts as a middleman, ensuring the agent's reasoning layer is decoupled from the actual tool execution.

This separation is the magic trick. The part of the AI that thinks and plans doesn't need to know how the tools work, just that they exist. And the tools don't need to know why they're being called. The control plane handles all that coordination.

The Brains of the Operation: The TutorAgent

Finally, we need the agent itself—the "thinker" that uses this whole system. Our TutorAgent will take a student's query, come up with a plan, and then use the control plane to execute that plan.

class TutorAgent:
    def __init__(self, control_plane: ControlPlane, api_key: str):
        self.control_plane = control_plane
        # We'd typically use an LLM here, but we'll simplify the planning
        # self.client = anthropic.Anthropic(api_key=api_key) 

    def teach(self, student_query: str) -> str:
        plan = self._plan_actions(student_query)
        results = []
        for action_plan in plan:
            result = self.control_plane.execute(action_plan)
            results.append(result)
        
        response = self._synthesize_response(student_query, results)
        return response

    def _plan_actions(self, query: str) -> List[Dict]:
        # In a real agent, an LLM would generate this plan.
        # We're using simple keyword matching for the demo.
        plan = []
        if "explain" in query.lower():
            plan.append({ "action": "search_knowledge", "parameters": {"query": query} })
        if "test" in query.lower():
            plan.append({ "action": "assess_understanding", "parameters": {"topic": "python"} })
        
        plan.append({ "action": "log_interaction", "parameters": {"event": "query_processed", "details": {"query": query}}})
        return plan

    def _synthesize_response(self, query: str, results: List[Dict]) -> str:
        # ... combines the results from the tools into a nice, readable answer ...

Here’s the flow:

1. A student asks a question, like "Test my understanding of Python basics."
2. The TutorAgent's _plan_actions method creates a multi-step plan. For this demo, it's just based on keywords, but in a more advanced system, you’d prompt an LLM to generate this plan. The plan might look like: [Assess understanding of Python, then log the interaction].
3. The agent sends each step of the plan to the ControlPlane for execution.
4. The control plane does its safety checks and runs the appropriate tools.
5. The agent gathers all the results and uses _synthesize_response to craft a final, helpful answer for the student.

Let's See It All in Action

When we tie everything together in a demo, the whole process becomes crystal clear.

def run_demo():
    # ... initialize all the components: Retriever, Registry, ControlPlane ...
    
    demo_queries = [
        "Explain Python functions to me",
        "Test my understanding of Python basics"
    ]

    for query in demo_queries:
        print(f"\n--- Query: {query} ---")
        # In a real run, this calls the agent's `teach` method
        # For our mock run, we'll simulate the plan and execution
        plan = [
            {"action": "search_knowledge", "parameters": {"query": query}},
            {"action": "log_interaction", "parameters": {"event": "query", "details": {}}}
        ]
        for action in plan:
            result = control_plane.execute(action)
            print(f"Action '{action['action']}' was successful: {result.get('success', False)}")

# ... when you run this ...
# --- Query: Explain Python functions to me ---
# Action 'search_knowledge' was successful: True
# Action 'log_interaction' was successful: True

Even in this simplified demo, you can see the structured, step-by-step process. The query comes in, a plan is made, and the control plane executes it safely. We can see the logs, track the state, and understand exactly what the AI did and why. There’s no mystery box here.

What we've built is more than just a simple AI tutor. It's a blueprint for creating responsible, scalable, and understandable AI agents. By separating the "thinking" (the agent's planning) from the "doing" (the tools) with a "manager" (the control plane), you gain an incredible amount of power and safety.

So the next time you set out to build an AI agent, don't just hand it a box of tools and hope for the best. Give it a control plane. Give it a manager. You’ll be amazed at how much more reliable and robust your creations become.