Most developers building AI workflows today are stuck in the cycle of prompt chaining. They send a request to an LLM, take the output, and feed it into another prompt, hoping the formatting remains consistent and the logic holds. This linear approach is brittle; a single hallucination or a missing comma in a JSON response can crash an entire pipeline. The industry is shifting toward agentic workflows, where the goal is not just to chain prompts, but to orchestrate specialized entities that can plan, execute, and critique their own work.

Building the Multi-Agent Architecture with CAMEL

The CAMEL framework provides the necessary infrastructure to move beyond simple chains into a coordinated multi-agent system. In a production-ready research pipeline, the workload is split across five distinct roles: a Planner, a Researcher, a Writer, a Critic, and a Rewriter. This division of labor ensures that no single agent is overwhelmed by too many constraints, allowing each to focus on a specific stage of the cognitive process.

To begin implementing this system in a cloud environment like Google Colab, the primary dependency is the CAMEL library. The setup requires a secure configuration of OpenAI API keys via environment secrets to maintain security during execution.

pip install camel-ai

Once the environment is ready, the system relies on a Model Factory to standardize how agents interact with the underlying LLM. This layer is critical because it handles the extraction of JSON from raw LLM responses, ensuring that the pipeline does not break when a model adds conversational filler around its data.

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType

To solve the problem of unpredictable LLM outputs, the pipeline employs Pydantic for structural validation. By defining strict schemas for plans and evidence, the system transforms free-form text into typed data structures. This means the Researcher cannot simply provide a vague summary; they must provide a source, a specific claim, and a relevance score.

from pydantic import BaseModel, Field
from typing import List, Optional

class Plan(BaseModel):

objective: str

steps: List[str]

class Evidence(BaseModel):

source: str

claim: str

relevance: float

With the schemas in place, the agents are initialized with specific system messages that enforce their boundaries. The Planner breaks down complex tasks, while the Researcher focuses on evidence gathering. This modularity allows developers to swap out individual agents or update their instructions without rebuilding the entire orchestration logic.

planner = ChatAgent(
 system_message="You are a planning expert. Break down complex tasks into structured steps.",
 model=model
)
researcher = ChatAgent(
 system_message="You are a research assistant. Find and summarize evidence from web sources.",
 model=model
)

From Linear Chaining to Iterative Refinement

The real shift in this architecture is the move from a one-way street to a feedback loop. Most AI pipelines fail because they lack a mechanism for self-correction. CAMEL addresses this through self-consistency sampling and a dedicated critique-rewrite cycle. Instead of accepting the first draft the Writer produces, the system generates multiple candidates and selects the most robust version.

def self_consistency_drafting(task, num_samples=3):
 drafts = []
 for _ in range(num_samples):
 draft = writer.step(task)
 drafts.append(draft)
 return select_best_draft(drafts)

This ensemble approach simulates a human editorial process. The Critic agent evaluates the selected draft against the original plan and the gathered evidence, assigning a score and identifying specific weaknesses. If the score falls below a predefined threshold, the Rewriter agent takes over, using the Critic's feedback to refine the content. This loop continues until the quality bar is met, effectively automating the manual polishing phase that usually requires human intervention.

for iteration in range(max_iterations):
 critique = critic.step(f"Evaluate this draft: {draft}")
 if critique.score >= threshold:
 break
 draft = rewriter.step(f"Improve based on: {critique.feedback}")

By integrating Pydantic-based validation with this iterative loop, the pipeline transforms the LLM from a creative writer into a reliable research engine. The tension between the Writer's tendency to hallucinate and the Critic's requirement for evidence creates a synthetic pressure that forces the output toward higher accuracy. The result is a system where the developer no longer manages prompts, but manages a process.

For those looking to implement this architecture, the complete codebase and interactive notebooks are available via the CAMEL GitHub repository.

This transition from prompt chaining to schema-validated, self-correcting agent pipelines marks the arrival of scalable AI orchestration in production environments.