{"id":778,"date":"2026-04-23T07:59:51","date_gmt":"2026-04-22T23:59:51","guid":{"rendered":"https:\/\/connectword.dpdns.org\/?p=778"},"modified":"2026-04-23T07:59:51","modified_gmt":"2026-04-22T23:59:51","slug":"how-to-design-a-production-grade-camel-multi-agent-system-with-planning-tool-use-self-consistency-and-critique-driven-refinement","status":"publish","type":"post","link":"https:\/\/connectword.dpdns.org\/?p=778","title":{"rendered":"How to Design a Production-Grade CAMEL Multi-Agent System with Planning, Tool Use, Self-Consistency, and Critique-Driven Refinement"},"content":{"rendered":"

In this tutorial, we implement an advanced agentic AI system using the CAMEL<\/strong><\/a> framework, orchestrating multiple specialized agents to collaboratively solve a complex task. We design a structured multi-agent pipeline consisting of a planner, researcher, writer, critic, and rewriter, each with clearly defined responsibilities and schema-constrained outputs. We integrate tool usage, self-consistency sampling, structured validation with Pydantic, and iterative critique-driven refinement to build a robust, research-backed technical brief generator. Through this process, we demonstrate how modern agent architectures combine planning, reasoning, external tool interaction, and autonomous quality control within a single coherent workflow.<\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
import os, sys, re, json, subprocess\nfrom typing import List, Dict, Any, Optional, Tuple\n\n\ndef _pip_install(pkgs: List[str]):\n   subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"-U\"] + pkgs)\n\n\n_pip_install([\"camel-ai[web_tools]~=0.2\", \"pydantic>=2.7\", \"rich>=13.7\"])\n\n\nfrom pydantic import BaseModel, Field\nfrom rich.console import Console\nfrom rich.panel import Panel\nfrom rich.table import Table\n\n\nconsole = Console()\n\n\ndef _get_colab_secret(name: str) -> Optional[str]:\n   try:\n       from google.colab import userdata\n       v = userdata.get(name)\n       return v if v else None\n   except Exception:\n       return None\n\n\ndef ensure_openai_key():\n   if os.getenv(\"OPENAI_API_KEY\"):\n       return\n   v = _get_colab_secret(\"OPENAI_API_KEY\")\n   if v:\n       os.environ[\"OPENAI_API_KEY\"] = v\n       return\n   try:\n       from getpass import getpass\n       k = getpass(\"Enter OPENAI_API_KEY (input hidden): \").strip()\n       if k:\n           os.environ[\"OPENAI_API_KEY\"] = k\n   except Exception:\n       pass\n\n\nensure_openai_key()\nif not os.getenv(\"OPENAI_API_KEY\"):\n   raise RuntimeError(\"OPENAI_API_KEY is not set. Add it via Colab Secrets (OPENAI_API_KEY) or paste it when prompted.\")<\/code><\/pre>\n<\/div>\n<\/div>\n
We set up the execution environment and install all required dependencies directly within Colab. We securely configure the OpenAI API key using either Colab secrets or manual input. We also initialize the console utilities that allow us to render structured outputs cleanly during execution.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
from camel.models import ModelFactory\nfrom camel.types import ModelPlatformType, ModelType\nfrom camel.agents import ChatAgent\nfrom camel.toolkits import SearchToolkit\n\n\ndef make_model(temperature: float = 0.2):\n   return ModelFactory.create(\n       model_platform=ModelPlatformType.OPENAI,\n       model_type=ModelType.GPT_4O,\n       model_config_dict={\"temperature\": float(temperature)},\n   )\n\n\ndef strip_code_fences(s: str) -> str:\n   s = s.strip()\n   s = re.sub(r\"^```(?:json)?s*\", \"\", s, flags=re.IGNORECASE)\n   s = re.sub(r\"s*```$\", \"\", s)\n   return s.strip()\n\n\ndef extract_first_json_object(s: str) -> str:\n   s2 = strip_code_fences(s)\n   start = None\n   stack = []\n   for i, ch in enumerate(s2):\n       if ch == \"{\":\n           if start is None:\n               start = i\n           stack.append(\"{\")\n       elif ch == \"}\":\n           if stack:\n               stack.pop()\n               if not stack and start is not None:\n                   return s2[start:i+1]\n   m = re.search(r\"{[sS]*}\", s2)\n   if m:\n       return m.group(0)\n   return s2<\/code><\/pre>\n<\/div>\n<\/div>\n
We import the core CAMEL components and define the model factory used across all agents. We implement helper utilities to clean and extract JSON reliably from LLM responses. This ensures that our multi-agent pipeline remains structurally robust even when models return formatted text.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
class PlanTask(BaseModel):\n   id: str = Field(..., min_length=1)\n   title: str = Field(..., min_length=1)\n   objective: str = Field(..., min_length=1)\n   deliverable: str = Field(..., min_length=1)\n   tool_hints: List[str] = Field(default_factory=list)\n   risks: List[str] = Field(default_factory=list)\n\n\nclass Plan(BaseModel):\n   goal: str\n   assumptions: List[str] = Field(default_factory=list)\n   tasks: List[PlanTask]\n   success_criteria: List[str] = Field(default_factory=list)\n\n\nclass EvidenceItem(BaseModel):\n   query: str\n   notes: str\n   key_points: List[str] = Field(default_factory=list)\n\n\nclass Critique(BaseModel):\n   score_0_to_10: float = Field(..., ge=0, le=10)\n   strengths: List[str] = Field(default_factory=list)\n   issues: List[str] = Field(default_factory=list)\n   fix_plan: List[str] = Field(default_factory=list)\n\n\nclass RunConfig(BaseModel):\n   goal: str\n   max_tasks: int = 5\n   max_searches_per_task: int = 2\n   max_revision_rounds: int = 1\n   self_consistency_samples: int = 2\n\n\nDEFAULT_GOAL = \"Create a concise, evidence-backed technical brief explaining CAMEL (the multi-agent framework), its core abstractions, and a practical recipe to build a tool-using multi-agent pipeline (planner\/researcher\/writer\/critic) with safeguards.\"\n\n\ncfg = RunConfig(goal=DEFAULT_GOAL)\n\n\nsearch_tool = SearchToolkit().search_duckduckgo<\/code><\/pre>\n<\/div>\n<\/div>\n
We define all structured schemas using Pydantic for planning, evidence, critique, and runtime configuration. We formalize the agent communication protocol so that every step is validated and typed. This allows us to transform free-form LLM outputs into predictable, production-ready data structures.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
planner_system = (\n   \"You are a senior agent architect. Produce a compact, high-leverage plan for achieving the goal.n\"\n   \"Return ONLY valid JSON that matches this schema:n\"\n   \"{{\"goal\": \"...\", \"assumptions\": [\"...\"], \"tasks\": \"\n   \"[{{\"id\": \"T1\", \"title\": \"...\", \"objective\": \"...\", \"deliverable\": \"...\", \"\n   \"\"tool_hints\": [\"...\"], \"risks\": [\"...\"]}}], \"\n   \"\"success_criteria\": [\"...\"]}}n\"\n   \"Constraints: tasks length <= {max_tasks}. Each task should be executable with web search + reasoning.\"\n).format(max_tasks=cfg.max_tasks)\n\n\nplanner = ChatAgent(system_message=planner_system, model=make_model(0.1))\n\n\nresearcher = ChatAgent(\n   system_message=(\n       \"You are a meticulous research agent. Use the web search tool when useful.n\"\n       \"You must:n\"\n       \"- Search for authoritative sources (docs, official repos) first.n\"\n       \"- Write notes that are directly relevant to the task objective.n\"\n       \"- Return ONLY valid JSON:n\"\n       \"{\"query\": \"...\", \"notes\": \"...\", \"key_points\": [\"...\"]}n\"\n       \"Do not include markdown code fences.\"\n   ),\n   model=make_model(0.2),\n   tools=[search_tool],\n)\n\n\nwriter = ChatAgent(\n   system_message=(\n       \"You are a technical writer agent. You will be given a goal, a plan, and evidence notes.n\"\n       \"Write a deliverable that is clear, actionable, and concise.n\"\n       \"Include:n\"\n       \"- A crisp overviewn\"\n       \"- Key abstractions and how they connectn\"\n       \"- A practical implementation recipen\"\n       \"- Minimal caveats\/limitationsn\"\n       \"Do NOT fabricate citations. If evidence is thin, state uncertainty.n\"\n       \"Return plain text only.\"\n   ),\n   model=make_model(0.3),\n)\n\n\ncritic = ChatAgent(\n   system_message=(\n       \"You are a strict reviewer. Evaluate the draft against the goal, correctness, and completeness.n\"\n       \"Return ONLY valid JSON:n\"\n       \"{\"score_0_to_10\": 0.0, \"strengths\": [\"...\"], \"issues\": [\"...\"], \"fix_plan\": [\"...\"]}n\"\n       \"Do not include markdown code fences.\"\n   ),\n   model=make_model(0.0),\n)\n\n\nrewriter = ChatAgent(\n   system_message=(\n       \"You are a revising editor. Improve the draft based on critique. Preserve factual accuracy.n\"\n       \"Return the improved draft as plain text only.\"\n   ),\n   model=make_model(0.25),\n)\n<\/code><\/pre>\n<\/div>\n<\/div>\n
We construct the specialized agents: planner, researcher, writer, critic, and rewriter. We define their system roles carefully to enforce task boundaries and structured behavior. This establishes the modular multi-agent architecture that enables collaboration and iterative refinement.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
def plan_goal(goal: str) -> Plan:\n   resp = planner.step(\"GOAL:n\" + goal + \"nnReturn JSON plan now.\")\n   raw = resp.msgs[0].content if hasattr(resp, \"msgs\") else resp.msg.content\n   js = extract_first_json_object(raw)\n   try:\n       return Plan.model_validate_json(js)\n   except Exception:\n       return Plan.model_validate(json.loads(js))\n\n\ndef research_task(task: PlanTask, goal: str, k: int) -> EvidenceItem:\n   prompt = (\n       \"GOAL:n\" + goal + \"nnTASK:n\" + task.model_dump_json(indent=2) + \"nn\"\n       f\"Perform research. Use at most {k} web searches. First search official documentation or GitHub if relevant.\"\n   )\n   resp = researcher.step(prompt)\n   raw = resp.msgs[0].content if hasattr(resp, \"msgs\") else resp.msg.content\n   js = extract_first_json_object(raw)\n   try:\n       return EvidenceItem.model_validate_json(js)\n   except Exception:\n       return EvidenceItem.model_validate(json.loads(js))\n\n\ndef draft_with_self_consistency(goal: str, plan: Plan, evidence: List[Tuple[PlanTask, EvidenceItem]], n: int) -> str:\n   packed_evidence = []\n   for t, ev in evidence:\n       packed_evidence.append({\n           \"task_id\": t.id,\n           \"task_title\": t.title,\n           \"objective\": t.objective,\n           \"notes\": ev.notes,\n           \"key_points\": ev.key_points\n       })\n   payload = {\n       \"goal\": goal,\n       \"assumptions\": plan.assumptions,\n       \"tasks\": [t.model_dump() for t in plan.tasks],\n       \"evidence\": packed_evidence,\n       \"success_criteria\": plan.success_criteria,\n   }\n   drafts = []\n   for _ in range(max(1, n)):\n       resp = writer.step(\"INPUT:n\" + json.dumps(payload, ensure_ascii=False, indent=2))\n       txt = resp.msgs[0].content if hasattr(resp, \"msgs\") else resp.msg.content\n       drafts.append(txt.strip())\n   if len(drafts) == 1:\n       return drafts[0]\n   chooser = ChatAgent(\n       system_message=(\n           \"You are a selector agent. Choose the best draft among candidates for correctness, clarity, and actionability.n\"\n           \"Return ONLY the winning draft text, unchanged.\"\n       ),\n       model=make_model(0.0),\n   )\n   resp = chooser.step(\"GOAL:n\" + goal + \"nnCANDIDATES:n\" + \"nn---nn\".join([f\"[DRAFT {i+1}]n{d}\" for i, d in enumerate(drafts)]))\n   return (resp.msgs[0].content if hasattr(resp, \"msgs\") else resp.msg.content).strip()<\/code><\/pre>\n<\/div>\n<\/div>\n
We implement the orchestration logic for planning, research, and self-consistent drafting. We aggregate structured evidence and generate multiple candidate drafts to improve robustness. We then select the best draft through an additional evaluation agent, simulating ensemble-style reasoning.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
def critique_text(goal: str, draft: str) -> Critique:\n   resp = critic.step(\"GOAL:n\" + goal + \"nnDRAFT:n\" + draft + \"nnReturn critique JSON now.\")\n   raw = resp.msgs[0].content if hasattr(resp, \"msgs\") else resp.msg.content\n   js = extract_first_json_object(raw)\n   try:\n       return Critique.model_validate_json(js)\n   except Exception:\n       return Critique.model_validate(json.loads(js))\n\n\ndef revise(goal: str, draft: str, critique: Critique) -> str:\n   resp = rewriter.step(\n       \"GOAL:n\" + goal +\n       \"nnCRITIQUE:n\" + critique.model_dump_json(indent=2) +\n       \"nnDRAFT:n\" + draft +\n       \"nnRewrite now.\"\n   )\n   return (resp.msgs[0].content if hasattr(resp, \"msgs\") else resp.msg.content).strip()\n\n\ndef pretty_plan(plan: Plan):\n   tab = Table(title=\"Agent Plan\", show_lines=True)\n   tab.add_column(\"ID\", style=\"bold\")\n   tab.add_column(\"Title\")\n   tab.add_column(\"Objective\")\n   tab.add_column(\"Deliverable\")\n   for t in plan.tasks:\n       tab.add_row(t.id, t.title, t.objective, t.deliverable)\n   console.print(tab)\n\n\ndef run(cfg: RunConfig):\n   console.print(Panel.fit(\"CAMEL Advanced Agentic Tutorial Runner\", style=\"bold\"))\n   plan = plan_goal(cfg.goal)\n   pretty_plan(plan)\n\n\n   evidence = []\n   for task in plan.tasks[: cfg.max_tasks]:\n       ev = research_task(task, cfg.goal, cfg.max_searches_per_task)\n       evidence.append((task, ev))\n\n\n   console.print(Panel.fit(\"Drafting (self-consistency)\", style=\"bold\"))\n   draft = draft_with_self_consistency(cfg.goal, plan, evidence, cfg.self_consistency_samples)\n\n\n   for r in range(cfg.max_revision_rounds + 1):\n       crit = critique_text(cfg.goal, draft)\n       console.print(Panel.fit(f\"Critique round {r+1} \u2014 score {crit.score_0_to_10:.1f}\/10\", style=\"bold\"))\n       if crit.strengths:\n           console.print(Panel(\"Strengths:n- \" + \"n- \".join(crit.strengths), title=\"Strengths\"))\n       if crit.issues:\n           console.print(Panel(\"Issues:n- \" + \"n- \".join(crit.issues), title=\"Issues\"))\n       if crit.fix_plan:\n           console.print(Panel(\"Fix plan:n- \" + \"n- \".join(crit.fix_plan), title=\"Fix plan\"))\n       if crit.score_0_to_10 >= 8.5 or r >= cfg.max_revision_rounds:\n           break\n       draft = revise(cfg.goal, draft, crit)\n\n\n   console.print(Panel.fit(\"FINAL DELIVERABLE\", style=\"bold green\"))\n   console.print(draft)\n\n\nrun(cfg)<\/code><\/pre>\n<\/div>\n<\/div>\n
We implement the critique-and-revision loop to enforce quality control. We score the draft, identify weaknesses, and iteratively refine it as needed. Finally, we execute the full pipeline, producing a structured, research-backed deliverable through coordinated collaboration among agents.<\/p>\n
In conclusion, we built a production-style CAMEL-based multi-agent system that goes far beyond simple prompt chaining. We structured agent communication through validated schemas, incorporated web search tools for grounded reasoning, applied self-consistency to improve output reliability, and enforced quality using an internal critic loop. By combining these advanced ideas, we showed how we can construct scalable, modular, and reliable agentic pipelines suitable for real-world AI applications.<\/p>\n
\n
Check out\u00a0the\u00a0Full Codes with Notebook here<\/a><\/strong>.\u00a0<\/strong>Also,\u00a0feel free to follow us on\u00a0Twitter<\/mark><\/a><\/strong>\u00a0and don\u2019t forget to join our\u00a0130k+ ML SubReddit<\/a><\/strong>\u00a0and Subscribe to\u00a0our Newsletter<\/a><\/strong>. Wait! are you on telegram?\u00a0now you can join us on telegram as well.<\/a><\/strong><\/p>\n
Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.?\u00a0Connect with us<\/mark><\/a><\/strong><\/p>\n
The post How to Design a Production-Grade CAMEL Multi-Agent System with Planning, Tool Use, Self-Consistency, and Critique-Driven Refinement<\/a> appeared first on MarkTechPost<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"
In this tutorial, we implement…<\/p>\n","protected":false},"author":1,"featured_media":29,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-778","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/778","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=778"}],"version-history":[{"count":0,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/778\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/media\/29"}],"wp:attachment":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=778"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=778"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=778"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}