Skip to main content
Weave for Agents is in public preview. Features, APIs, and the Agents view UI may change before general availability.
Pi is a terminal-based coding agent. Weave traces Pi sessions, LLM calls, and tool executions automatically using the createOtelExtension integration, which conforms to the GenAI semantic conventions. This page shows you how to enable Weave tracing in a Pi application so you can observe agent behavior, debug runs, and analyze token usage and cost.
This integration sends Pi session data to Weave. That data can include user prompts, model responses, tool inputs and outputs, file contents read by Pi tools, shell commands and output, and fetched URLs and page content.The integration doesn’t implement PII scrubbing or sensitive-data redaction. If you can’t send this data to Weave under your security or compliance requirements, don’t enable Weave tracing in your Pi application.

​
Prerequisites

  • Node.js (v18 or later).
  • A W&B account and API key set as a WANDB_API_KEY environment variable.
Pi is a TypeScript and Node.js framework with no Python equivalent. Pi requires the ESM module system. Your project must use "type": "module" in package.json, or compile TypeScript to ESM output. CommonJS projects error. For more information about setting up an ESM project, see TypeScript SDK integration.

​
Install packages

Install Weave, Pi, and Node type definitions as local project dependencies: 
npm install weave @earendil-works/pi-coding-agent
npm install --save-dev @types/node tsx typescript

​
Trace a Pi prompt and response

The following example shows the minimum setup needed to trace a single Pi prompt and response. Call weave.init() before you create your agent session, then pass createOtelExtension() as an extension factory. Weave traces the full agent lifecycle: the session, each prompt-and-response cycle (invoke_agent), individual LLM calls (chat), and tool executions (execute_tool). SessionManager.inMemory() generates the session ID automatically. 
import {init, createOtelExtension} from 'weave';

import {
  createAgentSession,
  DefaultResourceLoader,
  SessionManager,
  getAgentDir,
} from '@earendil-works/pi-coding-agent';

async function main() {
  // 1. Initialize Weave. Sets up the OTEL TracerProvider that points at your
  //    Weave project. All spans created by createOtelExtension() are
  //    automatically exported here.
  await init('[YOUR-TEAM]/[YOUR-PROJECT]');

  // 2. Create a resource loader and inject the Weave OTEL extension.
  //    The resource loader provides the Pi runtime environment and
  //    extension lifecycle used for tracing agent activity.
  const resourceLoader = new DefaultResourceLoader({
    cwd: process.cwd(),
    agentDir: getAgentDir(),
    extensionFactories: [createOtelExtension({})],
  });

  await resourceLoader.reload();

  // 3. Start the agent session
  const {session} = await createAgentSession({
    resourceLoader,
    sessionManager: SessionManager.inMemory(),
  });

  // 4. Bind extensions. Triggers session_start event so the OTEL adapter
  //    creates the root session span and captures the conversation ID.
  await session.bindExtensions({});

  // 5. Stream assistant output to stdout
  session.subscribe(event => {
    if (
      event.type === 'message_update' &&
      event.assistantMessageEvent.type === 'text_delta'
    ) {
      process.stdout.write(event.assistantMessageEvent.delta);
    }
  });

  // 6. Send a prompt and wait for the full response
  await session.prompt('What files are in the current directory?');
  console.log();
}

main();
Compile and execute the script with tsx, replacing [FILENAME] with the name of your TypeScript file: 
npx tsx [FILENAME].ts
When you run your code, your traces appear in the Agents tab of your Weave project at https://wandb.ai/[YOUR-TEAM]/[YOUR-PROJECT]/weave/agents. Weave captures Pi sessions, LLM calls, and tool executions for every run of your application.

​
Next steps

To turn this example into a multi-turn session, add more prompts. Weave traces each call to session.prompt() as a separate invoke_agent span, all nested under a single root span. The agent retains context across prompts automatically. After running the code, the Agents tab shows the full multi-turn timeline with nested LLM calls, tool executions, token usage, and cost.