Enhancing AI Transparency: Scanning CrewAI Workflows with Agentic Radar

CrewAI is an open-source framework designed to simplify the orchestration of autonomous AI agents, enabling seamless collaboration through intuitive assignments of roles, tools, and objectives. With its clean, declarative syntax, developers can effortlessly develop complex and high-performing agentic workflows.

Let’s dive deeper into a practical example to see CrewAI in action. We'll examine an agentic workflow that leverages multiple agents to automate the creation of surprise travel itineraries. Below is a Python code snippet showcasing how agents and tools are defined and organized within a single Crew (you can explore the complete example here).

class Activity(BaseModel):
	name: str = Field(..., description="Name of the activity")
	location: str = Field(..., description="Location of the activity")
	description: str = Field(..., description="Description of the activity")
	date: str = Field(..., description="Date of the activity")
	cousine: str = Field(..., description="Cousine of the restaurant")
	why_its_suitable: str = Field(..., description="Why it's suitable for the traveler")
	reviews: Optional[List[str]] = Field(..., description="List of reviews")
	rating: Optional[float] = Field(..., description="Rating of the activity")

class DayPlan(BaseModel):
	date: str = Field(..., description="Date of the day")
	activities: List[Activity] = Field(..., description="List of activities")
	restaurants: List[str] = Field(..., description="List of restaurants")
	flight: Optional[str] = Field(None, description="Flight information")

class Itinerary(BaseModel):
  name: str = Field(..., description="Name of the itinerary, something funny")
  day_plans: List[DayPlan] = Field(..., description="List of day plans")
  hotel: str = Field(..., description="Hotel information")

@CrewBase
class SurpriseTravelCrew():
	"""SurpriseTravel crew"""
	agents_config = 'config/agents.yaml'
	tasks_config = 'config/tasks.yaml'

	@agent
	def personalized_activity_planner(self) -> Agent:
    	return Agent(
        	config=self.agents_config['personalized_activity_planner'],
        	tools=[SerperDevTool(), ScrapeWebsiteTool()],
        	verbose=True,
        	allow_delegation=False,
    	)

	@agent
	def restaurant_scout(self) -> Agent:
    	return Agent(
        	config=self.agents_config['restaurant_scout'],
        	tools=[SerperDevTool(), ScrapeWebsiteTool()],
        	verbose=True,
        	allow_delegation=False,
    	)

	@agent
	def itinerary_compiler(self) -> Agent:
    	return Agent(
        	config=self.agents_config['itinerary_compiler'],
        	tools=[SerperDevTool()],
        	verbose=True,
        	allow_delegation=False,
    	)

	@task
	def personalized_activity_planning_task(self) -> Task:
    	return Task(
        	config=self.tasks_config['personalized_activity_planning_task'],
        	agent=self.personalized_activity_planner()
    	)

	@task
	def restaurant_scenic_location_scout_task(self) -> Task:
    	return Task(
        	config=self.tasks_config['restaurant_scenic_location_scout_task'],
        	agent=self.restaurant_scout()
    	)

	@task
	def itinerary_compilation_task(self) -> Task:
    	return Task(
        	config=self.tasks_config['itinerary_compilation_task'],
        	agent=self.itinerary_compiler(),
        	output_json=Itinerary
    	)

	@crew
	def crew(self) -> Crew:
    	"""Creates the SurpriseTravel crew"""
    	return Crew(
        	agents=self.agents
        	tasks=self.tasks,
        	process=Process.sequential,
        	verbose=2

As you can see above, setting up a workflow in CrewAI is pretty straightforward – even if you're completely new to the framework. However, clearly visualizing all the connections between different agents and tools can quickly become challenging, especially as the workflow grows in size and complexity. To illustrate this, let's first attempt to map these dependencies manually using our example workflow.

Finding Agents Manually

We can identify agents by the @agent function decorators. We can visualize them as graph nodes below.

Connecting Agents to Tools

To understand how each agent interacts with specific tools, we can inspect the tools keyword argument in their definitions. Our example utilizes two built-in CrewAI tools: ScrapeWebsiteTool and SerperDevTool. While these tools significantly enhance our agents' capabilities, they also introduce potential security risks, especially when interacting with external resources. For example, ScrapeWebsiteTool enables agents to extract data from web pages, potentially causing unintended data exposure or unauthorized scraping if not properly managed. Similarly, SerperDevTool grants search engine access, which could expose the system to risks such as uncontrolled queries or accidental leakage of sensitive information.

Let’s now incorporate these tools into our visualization and connect each of them to the corresponding agents.

Agent-to-Agent Interactions

Agentic systems reach their full potential when agents can dynamically communicate and collaborate, seamlessly exchanging information. To complete our visualization, it's essential to map the connections between agents themselves. This will give us a clear view of how data is flowing through the entire system.

To infer these agent-to-agent connections from our code, we first need to understand CrewAI’s core concept of Tasks. In CrewAI, tasks represent distinct units of work executed by agents. For example, the restaurant_scenic_location_scout_task encapsulates all necessary information, including input data, logic for processing, and expected outputs, enabling the assigned agent to find restaurants with scenic views. Each task explicitly assigns responsibility to a specific agent, defined via the agent keyword argument in the Task(...) constructor. Let’s manually extract these task-to-agent mappings next:

Another important concept to understand is CrewAI’s use of Processes, which orchestrate task execution across agents. In our example, we can identify the specific process by examining the process keyword argument within the Crew(...) constructor. Here, the process is set to Process.sequential, indicating that tasks will run sequentially, following the order they're defined in the Crew class. The output from each task is automatically passed as additional context to the next one, which helps the agent produce more meaningful and relevant results.

Given that agents are tied directly to tasks – and tasks execute sequentially – the agents' workflow naturally follows this same order. Now we have all the details needed to finalize our visualization. To make things even clearer, we’ll include explicit Start and End nodes to define the boundaries of our workflow.