OpenAI Agents SDK

Use W&B Weave with the OpenAI Agents SDK to track and monitor your agentic applications

You can use W&B Weave with the OpenAI Agents SDK to trace and monitor your agentic applications.

Python

The OpenAI Agents Python SDK is a lightweight and powerful framework for building multi-agent workflows.

Installation

Install the required dependencies using pip:

pip install weave openai-agents

Get started

To use the OpenAI Agents SDK with Weave:

• Initialize Weave with your project name.
• Add the Weave tracing processor to your agents.
• Create and run your agents as usual.

The following code sample creates an OpenAI Agent and integrates it with Weave for traceability. A Weave project is initialized and the WeaveTracingProcessor is set up to capture execution traces. A Weather data model represents weather information. The get_weather function is decorated as a tool the agent can use and returns a sample weather report. An agent named Hello world is configured with basic instructions and access to the weather tool. The main function runs the agent asynchronously with a sample input (What's the weather in Tokyo?) and prints the final response.

from pydantic import BaseModel
from agents import Agent, Runner, function_tool
import agents
import weave
import asyncio

weave.init("openai-agents")

class Weather(BaseModel):
    city: str
    temperature_range: str
    conditions: str

@function_tool
def get_weather(city: str) -> Weather:
    return Weather(city=city, temperature_range="14-20C", conditions="Sunny with wind.")

agent = Agent(
    name="Hello world",
    instructions="You are a helpful agent.",
    tools=[get_weather]
)

async def main():
    result = await Runner.run(agent, input="What's the weather in Tokyo?")    
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

View traces

When the above code sample is run, a link to the Weave dashboard is generated. Open the link to inspect traces from your agent run.

TypeScript

The OpenAI Agents Node SDK is a lightweight and powerful framework for building multi-agent workflows.

Installation

Install the required dependencies using npm. Weave’s TypeScript integration requires @openai/agents version 0.4.15 or later:

npm install weave @openai/agents zod

Get started

In most Node.js environments, manual instrumentation is not required.
Weave automatically instruments @openai/agents when the module is loaded.

Automatic instrumentation works by registering a module loader hook:

• CommonJS projects: No additional configuration is required.
• ESM projects: Node must be started with the --import=weave/instrument flag so the instrumentation loads before other modules.

If you need help setting up your project or determining which type you are using, see TypeScript SDK: Third-Party Integration Guide.

The following code sample creates an OpenAI Agent and integrates it with Weave for traceability. Replace your-team-name/your-project-name in the Weave project initialization with your entity and project. The sample defines a get_weather tool that returns a sample weather report, then configures an agent named Hello world with basic instructions and access to the weather tool. The main function runs the agent with a sample input (What's the weather in Tokyo?) and logs the final response.

import * as weave from "weave";
import { Agent, run, tool } from "@openai/agents";
import { z } from "zod";

const getWeather = tool({
  name: "get_weather",
  description: "Get the current weather for a given city.",
  parameters: z.object({
    city: z.string().describe("The name of the city"),
  }),
  async execute({ city }) {
    return `${city}: 14-20C, Sunny with wind.`;
  },
});

async function main() {
  // UPDATE to your project info.
  await weave.init("your-team-name/your-project-name");

  const agent = new Agent({
    name: "Hello world",
    instructions: "You are a helpful agent.",
    tools: [getWeather],
  });

  const result = await run(agent, [
    { role: "user", content: "What's the weather in Tokyo?" },
  ]);
  console.log(result.finalOutput);
}

main();

In CommonJS, the import * as weave from "weave" statement must appear before import { Agent, run, tool } from "@openai/agents" for automatic instrumentation. If your code cannot follow this ordering, use the manual instrumentation technique that follows.

Manual instrumentation

Manual instrumentation is only needed in cases where the module loader hook cannot run, such as:

• Bundlers that bundle dependencies into a single file.
• Environments where Node CLI flags cannot be passed.
• Dynamic module loading patterns that bypass the loader hook.

In these cases, you can explicitly register the instrumentation by using instrumentOpenAIAgents():

import * as weave from "weave";

await weave.init("openai-agents");
await weave.instrumentOpenAIAgents();

For full control over the tracing processor, such as for custom processor configuration or conditional registration, create and register one manually:

import { addTraceProcessor } from "@openai/agents";
import { createOpenAIAgentsTracingProcessor } from "weave";

...

const processor = createOpenAIAgentsTracingProcessor();
addTraceProcessor(processor);