OpenAI Agents SDK - Weights & Biases Documentation

You can use W&B Weave with the OpenAI Agents SDK to trace and monitor your agentic applications. This guide shows you how to install the integration, initialize Weave in your agent code, and view the resulting traces in the Weave dashboard so you can debug and evaluate multi-agent workflows.

Python
TypeScript

The OpenAI Agents Python SDK is a lightweight 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. The sample initializes a Weave project and sets up the WeaveTracingProcessor to capture execution traces. A Weather data model represents weather information. The get_weather function, decorated as a tool the agent can use, returns a sample weather report. An agent named Hello world uses 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 you run the previous code sample, Weave generates a link to the Weave dashboard. Open the link to inspect traces from your agent run.

The OpenAI Agents Node SDK is a lightweight 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, you don’t need manual instrumentation. Weave automatically instruments @openai/agents when the module loads.Automatic instrumentation works by registering a module loader hook:

CommonJS projects: No additional configuration is required.
ESM projects: Start Node 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’re 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

You only need manual instrumentation in cases where the module loader hook can’t run, such as:

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

In these cases, you can explicitly register the instrumentation with 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);

​Installation

​Get started

​View traces

​Installation

​Get started

​Manual instrumentation

Installation

Get started

View traces

Installation

Get started

Manual instrumentation