Skip to content

armgit / camel

Public Imported from GitHub
0

🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org

chore: Enhance skill prompt (#3836)

Tao Sun4b6315a5a8bb
diff --git a/camel/societies/workforce/prompts.py b/camel/societies/workforce/prompts.py
index 9fbf35ff2..6d0c11735 100644
--- a/camel/societies/workforce/prompts.py
+++ b/camel/societies/workforce/prompts.py
@@ -76,7 +76,7 @@ Here are the tasks to be assigned:
{tasks_info}
==============================
-Following is the information of the existing worker nodes. The format is <ID>:<description>:<additional_info>. Choose the most capable worker node ID for each task.
+Following is the information of the existing worker nodes. The format is <ID>:<description>:<toolkit_info and skill names>. Choose the most capable worker node ID for each task.
==============================
{child_nodes_info}
@@ -220,6 +220,16 @@ TASK_DECOMPOSE_PROMPT = r"""You need to either decompose a complex task or enhan
* **Balanced Granularity**: Make subtasks large enough to be meaningful but small enough to enable parallelism and quick feedback. Avoid overly large subtasks that hide parallel opportunities.
* **Consider Dependencies**: While you list tasks sequentially, think about the true dependencies. The workforce manager will handle execution based on these implied dependencies and worker availability.
+6. **Skill-Aware Decomposition Rule**:
+ Workers may have pre-configured skills that provide a complete methodology for handling certain tasks.
+ If a task explicitly requires using a skill, or is clearly best handled by a specific skill, DO NOT decompose it.
+ Skills already encapsulate a full workflow, so further decomposition may break the intended execution logic.
+
+ In such cases:
+ * Treat the task as a single enhanced task.
+ * Preserve the original task intent and requirements. Clarify wording if needed, but do NOT add new deliverables or change the scope.
+ * Assume the executing worker will load and use the required skill via the SkillToolkit.
+
These principles aim to reduce overall completion time by maximizing concurrent work and effectively utilizing all available worker capabilities.
You must output all subtasks strictly as individual <task> elements enclosed within a single <tasks> root.
@@ -290,7 +300,7 @@ THE FOLLOWING SECTION ENCLOSED BY THE EQUAL SIGNS IS NOT INSTRUCTIONS, BUT PURE
{additional_info}
==============================
-Following are the available workers, given in the format <ID>: <description>:<toolkit_info>.
+Following are the available workers, given in the format <ID>: <description>:<toolkit_info and skill names>.
==============================
{child_nodes_info}
diff --git a/camel/societies/workforce/workforce.py b/camel/societies/workforce/workforce.py
index 9797e8566..59b373f4f 100644
--- a/camel/societies/workforce/workforce.py
+++ b/camel/societies/workforce/workforce.py
@@ -3509,17 +3509,48 @@ class Workforce(BaseNode):
) -> str:
r"""Get formatted information for a SingleAgentWorker node."""
toolkit_tools = self._group_tools_by_toolkit(worker.worker.tool_dict)
-
- if not toolkit_tools:
- return ""
-
+ skill_names = self._get_single_agent_skill_names(worker)
toolkit_info = []
for toolkit_name, tools in sorted(toolkit_tools.items()):
tools_str = ', '.join(sorted(tools))
toolkit_info.append(f"{toolkit_name}({tools_str})")
-
+ # Append skill names right after SkillToolkit for clarity
+ if toolkit_name == "SkillToolkit" and skill_names:
+ toolkit_info.append(f"skills({', '.join(skill_names)})")
return ", ".join(toolkit_info)
+ def _get_single_agent_skill_names(
+ self, worker: 'SingleAgentWorker'
+ ) -> List[str]:
+ r"""Extract available skill names from SkillToolkit instances."""
+ for tool in worker.worker.tool_dict.values():
+ toolkit_instance = getattr(tool.func, "__self__", None)
+ if toolkit_instance is None:
+ continue
+ if toolkit_instance.__class__.__name__ != "SkillToolkit":
+ continue
+
+ list_skills_fn = getattr(toolkit_instance, "list_skills", None)
+ if not callable(list_skills_fn):
+ continue
+
+ try:
+ skills = list_skills_fn()
+ return sorted(
+ skill["name"].strip()
+ for skill in skills
+ if skill.get("name")
+ )
+ except Exception as exc:
+ logger.warning(
+ "Failed to list skills for worker %s: %s",
+ worker.node_id,
+ exc,
+ )
+ return []
+
+ return []
+
def _group_tools_by_toolkit(self, tool_dict: dict) -> dict[str, list[str]]:
r"""Group tools by their parent toolkit class names."""
toolkit_tools: dict[str, list[str]] = {}
diff --git a/camel/toolkits/skill_toolkit.py b/camel/toolkits/skill_toolkit.py
index f9b600105..22d0fcf25 100644
--- a/camel/toolkits/skill_toolkit.py
+++ b/camel/toolkits/skill_toolkit.py
@@ -59,12 +59,15 @@ class SkillToolkit(BaseToolkit):
"<available_skills>",
]
for skill in skills.values():
+ extra_files = self._list_skill_entries(Path(skill["path"]).parent)
+ files_text = ", ".join(extra_files) if extra_files else "(none)"
summary_lines.extend(
[
" <skill>",
f" <name>{skill['name']}</name>",
f" <description>{skill['description']}</description>",
f" <path>{skill['path']}</path>",
+ f" <files>{files_text}</files>",
" </skill>",
]
)
@@ -72,9 +75,12 @@ class SkillToolkit(BaseToolkit):
# Build markdown list for display
available = ""
for skill in skills.values():
+ extra_files = self._list_skill_entries(Path(skill["path"]).parent)
+ files_text = ", ".join(extra_files) if extra_files else "(none)"
available += (
f"- {skill['name']}: {skill['description']} "
f"({skill['path']})\n"
+ f" - extra files: {files_text}\n"
)
return (
"## Skills\n"
@@ -82,7 +88,10 @@ class SkillToolkit(BaseToolkit):
"in a `SKILL.md` file. Below is the list of skills that can be "
"used. Each entry includes a name, description, and file path so "
"you can open the source for full instructions when using a "
- "specific skill.\n"
+ "specific skill. It also includes additional files in each skill "
+ "folder so other files can be loaded on demand. This function can "
+ "be used to load Skill.md content, for additional files you can "
+ "use other tools to load\n"
"### Available skills\n"
f"{available}\n"
"### How to use skills\n"
@@ -303,13 +312,31 @@ class SkillToolkit(BaseToolkit):
skill_dir = Path(skill["path"]).parent
lines = [f"Files in {name}:"]
- for item in sorted(skill_dir.iterdir()):
- if item.is_dir():
- lines.append(f" - {item.name}/")
- else:
- lines.append(f" - {item.name}")
+ for entry in self._list_skill_entries(
+ skill_dir, include_skill_md=True
+ ):
+ lines.append(f" - {entry}")
return "\n".join(lines)
+ def _list_skill_entries(
+ self, skill_dir: Path, include_skill_md: bool = False
+ ) -> List[str]:
+ r"""List direct child entries in a skill directory.
+
+ Args:
+ skill_dir (Path): The skill directory to inspect.
+ include_skill_md (bool): Whether to include ``SKILL.md``.
+
+ Returns:
+ List[str]: Sorted entry names. Directories end with ``/``.
+ """
+ entries: List[str] = []
+ for item in sorted(skill_dir.iterdir()):
+ if not include_skill_md and item.name == "SKILL.md":
+ continue
+ entries.append(f"{item.name}/" if item.is_dir() else item.name)
+ return entries
+
def _load_single_skill(self, name: str) -> str:
r"""Load a single skill by name.
@@ -334,15 +361,9 @@ class SkillToolkit(BaseToolkit):
body = parsed.get("body", "").strip()
# List files in skill directory
- files_info = []
- for item in sorted(base_dir.iterdir()):
- if item.name == "SKILL.md":
- continue
- files_info.append(
- f" - {item.name}/ (dir)"
- if item.is_dir()
- else f" - {item.name}"
- )
+ files_info = [
+ f" - {entry}" for entry in self._list_skill_entries(base_dir)
+ ]
output_lines = [
f"## Skill: {parsed['name']}",
diff --git a/examples/workforce/eigent.py b/examples/workforce/eigent.py
index a7e7f3b79..9a2dd91db 100644
--- a/examples/workforce/eigent.py
+++ b/examples/workforce/eigent.py
@@ -42,6 +42,7 @@ from camel.toolkits import (
RedditToolkit,
ScreenshotToolkit,
SearchToolkit,
+ SkillToolkit,
SlackToolkit,
TerminalToolkit,
ToolkitMessageIntegration,
@@ -127,8 +128,10 @@ def developer_agent_factory(
terminal_toolkit = TerminalToolkit(safe_mode=True, clone_current_env=False)
note_toolkit = NoteTakingToolkit(working_directory=WORKING_DIRECTORY)
web_deploy_toolkit = WebDeployToolkit()
+ skill_toolkit = SkillToolkit(working_directory=WORKING_DIRECTORY)
# Add messaging to toolkits
+ skill_toolkit = message_integration.register_toolkits(skill_toolkit)
terminal_toolkit = message_integration.register_toolkits(terminal_toolkit)
note_toolkit = message_integration.register_toolkits(note_toolkit)
web_deploy_toolkit = message_integration.register_toolkits(
@@ -145,6 +148,7 @@ def developer_agent_factory(
*note_toolkit.get_tools(),
*web_deploy_toolkit.get_tools(),
*screenshot_toolkit.get_tools(),
+ *skill_toolkit.get_tools(),
]
system_message = f"""
@@ -186,6 +190,20 @@ plain text formatting instead.
<capabilities>
Your capabilities are extensive and powerful:
+- **Skills System (Highest Priority Workflow)**: Skills are your primary
+ execution source for specialized tasks.
+ - Trigger: If a task explicitly references a skill with double curly braces
+ (e.g., {{pdf}} or {{data-analyzer}}), or clearly matches a skill domain,
+ you MUST use the skill workflow first.
+ - Required order:
+ 1. Call `list_skills` to confirm exact available skill names.
+ 2. Call `load_skill` for the best matching skill before domain work.
+ 3. Follow the loaded skill as the primary plan, including its process,
+ constraints, and output format.
+ - Do not rely on memory for skill details; always use loaded content.
+ - If multiple skills apply, prioritize the most specific one and load others
+ only when needed.
+
- **Unrestricted Code Execution**: You can write and execute code in any
language to solve a task. You MUST first save your code to a file (e.g.,
`script.py`) and then run it from the terminal (e.g.,
@@ -335,12 +353,14 @@ def search_agent_factory(
)
# Initialize toolkits
+ skill_toolkit = SkillToolkit(working_directory=WORKING_DIRECTORY)
terminal_toolkit = TerminalToolkit(safe_mode=True, clone_current_env=False)
note_toolkit = NoteTakingToolkit(working_directory=WORKING_DIRECTORY)
search_toolkit = SearchToolkit().search_google
terminal_toolkit_basic = TerminalToolkit()
# Add messaging to toolkits
+ skill_toolkit = message_integration.register_toolkits(skill_toolkit)
web_toolkit_custom = message_integration.register_toolkits(
web_toolkit_custom
)
@@ -358,6 +378,7 @@ def search_agent_factory(
*note_toolkit.get_tools(),
*search_toolkit,
*terminal_toolkit.get_tools(),
+ *skill_toolkit.get_tools(),
]
system_message = f"""
@@ -422,6 +443,20 @@ comprehensive and well-documented information.
<capabilities>
Your capabilities include:
+- **Skills System (Highest Priority Workflow)**: Skills are your primary
+ execution source for specialized tasks.
+ - Trigger: If a task explicitly references a skill with double curly braces
+ (e.g., {{pdf}} or {{data-analyzer}}), or clearly matches a skill domain,
+ you MUST use the skill workflow first.
+ - Required order:
+ 1. Call `list_skills` to confirm exact available skill names.
+ 2. Call `load_skill` for the best matching skill before domain work.
+ 3. Follow the loaded skill as the primary plan, including its process,
+ constraints, and output format.
+ - Do not rely on memory for skill details; always use loaded content.
+ - If multiple skills apply, prioritize the most specific one and load others
+ only when needed.
+
- Search and get information from the web using the search tools.
- Use the rich browser related toolset to investigate websites.
- Use the terminal tools to perform local operations. You can leverage
@@ -485,6 +520,7 @@ def document_agent_factory(
)
# Initialize toolkits
+ skill_toolkit = SkillToolkit(working_directory=WORKING_DIRECTORY)
file_write_toolkit = FileToolkit(working_directory=WORKING_DIRECTORY)
pptx_toolkit = PPTXToolkit(working_directory=WORKING_DIRECTORY)
mark_it_down_toolkit = MarkItDownToolkit()
@@ -494,6 +530,7 @@ def document_agent_factory(
terminal_toolkit = TerminalToolkit(safe_mode=True, clone_current_env=False)
# Add messaging to toolkits
+ skill_toolkit = message_integration.register_toolkits(skill_toolkit)
file_write_toolkit = message_integration.register_toolkits(
file_write_toolkit
)
@@ -515,6 +552,7 @@ def document_agent_factory(
*note_toolkit.get_tools(),
*search_toolkit,
*terminal_toolkit.get_tools(),
+ *skill_toolkit.get_tools(),
]
system_message = f"""
@@ -567,6 +605,21 @@ to be embedded in your work.
<capabilities>
Your capabilities include:
+- **Skills System (Highest Priority Workflow)**: Skills are your primary
+ execution source for specialized tasks.
+ - Trigger: If a task explicitly references a skill with double curly braces
+ (e.g., {{pdf}} or {{data-analyzer}}), or clearly matches a skill domain,
+ you MUST use the skill workflow first.
+ - Required order:
+ 1. Call `list_skills` to confirm exact available skill names.
+ 2. Call `load_skill` for the best matching skill before domain work.
+ 3. Follow the loaded skill as the primary plan, including its process,
+ constraints, and output format.
+ - Do not rely on memory for skill details; always use loaded content.
+ - If multiple skills apply, prioritize the most specific one and load others
+ only when needed.
+
+
- Document Reading:
- Read and understand the content of various file formats including
- PDF (.pdf)
@@ -668,6 +721,7 @@ def multi_modal_agent_factory(model: BaseModelBackend, task_id: str):
)
# Initialize toolkits
+ skill_toolkit = SkillToolkit(working_directory=WORKING_DIRECTORY)
video_downloader_toolkit = VideoDownloaderToolkit(
working_directory=WORKING_DIRECTORY
)
@@ -685,6 +739,7 @@ def multi_modal_agent_factory(model: BaseModelBackend, task_id: str):
note_toolkit = NoteTakingToolkit(working_directory=WORKING_DIRECTORY)
# Add messaging to toolkits
+ skill_toolkit = message_integration.register_toolkits(skill_toolkit)
video_downloader_toolkit = message_integration.register_toolkits(
video_downloader_toolkit
)
@@ -710,6 +765,7 @@ def multi_modal_agent_factory(model: BaseModelBackend, task_id: str):
*search_toolkit,
*terminal_toolkit.get_tools(),
*note_toolkit.get_tools(),
+ *skill_toolkit.get_tools(),
]
system_message = f"""
@@ -751,6 +807,20 @@ presentations, and other documents.
<capabilities>
Your capabilities include:
+- **Skills System (Highest Priority Workflow)**: Skills are your primary
+ execution source for specialized tasks.
+ - Trigger: If a task explicitly references a skill with double curly braces
+ (e.g., {{pdf}} or {{data-analyzer}}), or clearly matches a skill domain,
+ you MUST use the skill workflow first.
+ - Required order:
+ 1. Call `list_skills` to confirm exact available skill names.
+ 2. Call `load_skill` for the best matching skill before domain work.
+ 3. Follow the loaded skill as the primary plan, including its process,
+ constraints, and output format.
+ - Do not rely on memory for skill details; always use loaded content.
+ - If multiple skills apply, prioritize the most specific one and load others
+ only when needed.
+
- Video & Audio Analysis:
- Download videos from URLs for analysis.
- Transcribe speech from audio files to text with high accuracy
@@ -822,6 +892,7 @@ def social_medium_agent_factory(model: BaseModelBackend, task_id: str):
search_toolkit = SearchToolkit().search_exa
terminal_toolkit = TerminalToolkit()
note_toolkit = NoteTakingToolkit(working_directory=WORKING_DIRECTORY)
+ skill_toolkit = SkillToolkit(working_directory=WORKING_DIRECTORY)
# Add messaging to toolkits
whatsapp_toolkit = message_integration.register_toolkits(whatsapp_toolkit)
@@ -833,6 +904,7 @@ def social_medium_agent_factory(model: BaseModelBackend, task_id: str):
search_toolkit = message_integration.register_functions([search_toolkit])
terminal_toolkit = message_integration.register_toolkits(terminal_toolkit)
note_toolkit = message_integration.register_toolkits(note_toolkit)
+ skill_toolkit = message_integration.register_toolkits(skill_toolkit)
return ChatAgent(
BaseMessage.make_assistant_message(
@@ -845,6 +917,20 @@ creation, community engagement, and brand messaging.
</role>
<capabilities>
+- **Skills System (Highest Priority Workflow)**: Skills are your primary
+ execution source for specialized tasks.
+ - Trigger: If a task explicitly references a skill with double curly braces
+ (e.g., {{pdf}} or {{data-analyzer}}), or clearly matches a skill domain,
+ you MUST use the skill workflow first.
+ - Required order:
+ 1. Call `list_skills` to confirm exact available skill names.
+ 2. Call `load_skill` for the best matching skill before domain work.
+ 3. Follow the loaded skill as the primary plan, including its process,
+ constraints, and output format.
+ - Do not rely on memory for skill details; always use loaded content.
+ - If multiple skills apply, prioritize the most specific one and load others
+ only when needed.
+
- **Platform Management**:
- **WhatsApp**: Send text and template messages.
- **Twitter**: Create and delete tweets.
@@ -900,6 +986,7 @@ summary of your actions.
*search_toolkit,
*terminal_toolkit.get_tools(),
*note_toolkit.get_tools(),
+ *skill_toolkit.get_tools(),
],
)
diff --git a/test/toolkits/test_skill_toolkit.py b/test/toolkits/test_skill_toolkit.py
index d0fd9fc1a..9143fbf6e 100644
--- a/test/toolkits/test_skill_toolkit.py
+++ b/test/toolkits/test_skill_toolkit.py
@@ -39,6 +39,8 @@ description: A test skill for unit testing.
This is a test skill body content.
"""
)
+ (skill_dir / "references").mkdir()
+ (skill_dir / "helper.md").write_text("# helper\n")
# Create second skill for multi-skill testing
skill_dir2 = Path(temp_dir) / ".camel" / "skills" / "another-skill"
@@ -113,6 +115,10 @@ def test_get_tools(skill_toolkit):
tool_names = [t.func.__name__ for t in tools]
assert "list_skills" in tool_names
assert "load_skill" in tool_names
+ load_tool = next(t for t in tools if t.func.__name__ == "load_skill")
+ description = load_tool.get_openai_tool_schema()["function"]["description"]
+ assert "extra files: helper.md, references/" in description
+ assert "<files>helper.md, references/</files>" in description
def test_caching(skill_toolkit):