We're excited to share that Agentic Radar, our open-source AI transparency scanner, now supports agentic workflows built with the newly released OpenAI Agents SDK. This open-source SDK makes it easier for developers to build and manage both single-agent and multi-agent systems, offering a streamlined way to orchestrate AI workflows using OpenAI's Responses API. It also comes with out-of-the-box support for tools like web search, file retrieval, and code execution.
To see how this works in practice, let’s explore a simple workflow built with the OpenAI Agents SDK and walk through how Agentic Radar scans it for transparency.
Agents
Agents are the fundamental building blocks of an agentic workflow. In the OpenAI Agents SDK, each agent is defined with a name and a set of instructions that describe its role and capabilities within the system. In our airline customer support scenario, the workflow consists of three agents:
FAQ Agent – handles common questions about airline policies, such as baggage allowances, seating options, and onboard services
Seat Booking Agent – helps customers modify or update their seat selections
Triage Agent – serves as the central router, directing each customer request to the appropriate agent
Agents are instantiated using the Agent
constructor, as shown in the example below.
Tools
Tools are essential to how agents interact with the outside world. In the OpenAI Agents SDK, tools allow agents to call external functions, access APIs, or even delegate tasks to other agents. There are three main types of tools supported:
Hosted (predefined) tools – built-in tools provided and managed by OpenAI
Function calling (custom) tools – custom tools created with regular Python functions
Agents as tools – allow agents to call other agents without handing over control to them
We detect Python functions decorated with @function_tool
as custom tools. Here’s an example:
In this example, the faq_lookup_tool
enables the FAQ Agent to search for a relevant answer to the user’s question. Each agent is given access to a specific set of tools it can call when needed. Tools are assigned to agents via the tools
keyword argument in the Agent
constructor, as shown below:
In our example, the FAQ Agent is also equipped with FileSearchTool
– a hosted (predefined) tool provided by OpenAI – which it can use to search through a document-based knowledge base of frequently asked questions.
Handoffs
Handoffs make it possible for agents to delegate tasks to other specialized agents, helping ensure that each query is handled efficiently. In our airline customer support workflow, the Triage Agent uses handoffs to route customer requests based on intent:
To the FAQ Agent, for general questions about baggage, seating, or onboard services
To the Seat Booking Agent, when a customer wants to change their seat
Handoffs are defined using the handoffs
parameter, which accepts either an agent instance or a Handoff
object for more advanced customizations. The SDK also includes a handoff()
helper function that lets developers fine-tune routing behavior by specifying the target agent, applying input filters, or setting custom overrides.
Why use Agentic Radar?
While each agent operates within clear instructions and defined constraints, complexity increases quickly as workflows scale. As agents begin to interact, delegate tasks, and call tools, it becomes critical to maintain transparency and control.
That’s where Agentic Radar comes in.
Agentic Radar helps developers visualize agent interactions and uncover potential risks in multi-agent systems. By analyzing the structure and execution flow of a workflow, it provides insights into:
Handoff Loops – detects situations where agents might repeatedly hand off control without resolving the user’s request
Tool Misuse – highlights instances where agents may invoke the wrong tool or use a tool in unintended ways
Tool Vulnerabilities – maps tools to known risks from the OWASP frameworks for LLMs and Agentic AI and flags possible security concerns, and offers actionable remediation steps
With Agentic Radar, developers gain a clearer understanding of how their agentic systems behave – and what potential vulnerabilities might be hidden in them.
Detecting Workflow Vulnerabilities with Agentic Radar
Let’s run Agentic Radar on our airline customer support example.
Install Agentic Radar by following the steps in the official GitHub repository.
Copy the full Python example into a folder – for example:
./airline_customer_support/main.py
Run the scanner using the following command:
agentic-radar -i ./airline_customer_support -o report.html openai-agents
Open the generated
report.html
file in your browser.
At the top of the report, you’ll see an interactive graph showing the agentic workflow – nodes represent agents, tools, and handoffs, while connections show how they interact. You can zoom, pan, and rearrange nodes to explore the structure more easily.

Just below the visualization, you’ll find a summary of Agentic Radar’s findings – this includes a breakdown of detected agents, tools, and any potential vulnerabilities identified in the workflow.


What's next for Agentic Radar?
As agentic workflows grow in complexity and adoption, transparency and security become mission-critical. Agentic Radar will continue to evolve – offering deeper visibility into multi-agent interactions, surfacing emerging vulnerabilities, and strengthening alignment with security frameworks like OWASP.
Looking ahead, we’re working on expanding Agentic Radar’s capabilities to cover even more critical areas of agentic systems, including:
Analyzing and visualizing system prompts
Tracking agent data sources and tool inputs
Mapping integrations with MCP servers and external endpoints
Supporting additional orchestration frameworks like PydanticAI and Dify
There’s a lot more on the horizon. In the meantime, if you have feedback or feature requests, we’d love to hear from you – join our Community Discord Server or open an issue on GitHub.
And if Agentic Radar helps you build safer, more transparent AI systems, consider giving the project a ⭐ on GitHub – it goes a long way in supporting the community and our efforts in creating a future of trusted and secure agentic workflows.
Table of contents