How do I switch from LangSmith to Rius for the OpenAI Agents SDK?

Rius traces the OpenAI Agents SDK through its OpenAI integration, so you swap LangSmith’s setup for one rius.init() call and a few observe wrappers. Every model call arrives as a generation with model, tokens and cost, and your wrappers give the agent run and its tools their shape. You can run both backends side by side until Rius shows what you need, then remove LangSmith. Rius supports the OpenAI Agents SDK in Python.

How it works

The framework drives the OpenAI client underneath, so the Rius openai integration captures its model calls without framework-specific code. rius.init() turns that on for the whole process. The LangSmith client wrapper wrap_openai has no Rius counterpart, because there is no per-client wrapper to remember.

The agent loop, tool runs and handoffs happen inside the framework, so you add observe wrappers around your entrypoint and your tool bodies. That is the only code you add.

How your LangSmith setup maps over:

• LANGSMITH_TRACING, LANGSMITH_API_KEY and LANGSMITH_PROJECT become RIUS_API_KEY plus rius.init(service_name="my-agent"). A LangSmith project corresponds to a Rius agent, named by service.name.
• wrap_openai(OpenAI()) becomes a plain OpenAI().
• LangSmith’s OpenAIAgentsTracingProcessor, registered with set_trace_processors, goes away. The observe wrappers replace the run structure it recorded.
• @traceable becomes @rius.observe, and @traceable(run_type="tool") becomes @rius.observe(kind=rius.SpanKind.TOOL).
• A thread_id in metadata becomes with rius.session(thread_id): around the call. It stamps session.id on every span inside it, so you set it once per request.

The OpenAI Agents SDK integration page covers the framework in full, and the LangSmith migration guide has the complete mapping table.

Set it up

1. Install the SDK with the openai extra, plus the framework:

   pip install "glassflow-rius[openai]" openai-agents

2. Replace the LangSmith setup in your startup code with rius.init(). Wrap the entrypoint as an AGENT span and each tool body as a TOOL span. Put @function_tool outermost and observe on the function body, because the framework reads the function signature for the tool schema. Remove @traceable and wrap_openai from this code.

   import rius
   from agents import Agent, Runner, function_tool, set_tracing_disabled
   from rius import SpanKind
    
   rius.init(api_key="ri_...", service_name="my-agent")
   set_tracing_disabled(True)
    
   @function_tool
   @rius.observe(kind=SpanKind.TOOL)
   def account_status(email: str) -> str:
       """Fetch a customer's account standing by email."""
       return lookup(email)
    
   support_agent = Agent(
       name="support_agent",
       instructions="Answer support questions; check accounts with the tool.",
       tools=[account_status],
       model="gpt-5-mini",
   )
    
   @rius.observe(name="handle-ticket", kind=SpanKind.AGENT)
   def handle_ticket(ticket: str) -> str:
       result = Runner.run_sync(support_agent, ticket)
       return str(result.final_output)
    
   with rius.session("ticket-1042"):
       handle_ticket("My invoice shows two charges.")

3. Decide about the framework’s own tracing. It uploads to the OpenAI platform, is independent of OpenTelemetry, and is also the path LangSmith’s OpenAIAgentsTracingProcessor reads from. set_tracing_disabled(True) makes Rius the single telemetry path, so if you compare against LangSmith first, leave that line out until you cut over. Leaving it on does not interfere with Rius.

4. Use underscores in agent names. A hyphen gets rewritten in the generated handoff tool name, and the framework warns on every run.

5. Replace thread_id metadata with rius.session(), reusing your conversation or ticket id, so every turn of a conversation groups together.

6. Run one request that calls a tool and open the trace in the console. Compare it with LangSmith for a few days, then unset LANGSMITH_TRACING, remove the remaining @traceable decorators and revoke the LangSmith keys. The Migrate to Rius guide lists the other tools you can move from.

What you get

The trace for one run looks like this:

handle-ticket                    AGENT   9.8s
├─ Response                      LLM     2.3s   triage decides to hand off
├─ Response                      LLM     2.8s   billing agent decides to call the tool
├─ execute_tool account_status   TOOL    0ms
└─ Response                      LLM     4.6s   billing agent answers

• The root AGENT span is your entrypoint wrapper.
• Each model call is an LLM generation with model, tokens, cost and time to first token. Cost is a list-price estimate in US dollars that Rius computes from the model and token counts, so you never send it.
• Each function tool is a TOOL span with the name you gave it.
• Conversations group into sessions.

Two behaviours differ from what you may expect. A handoff has no span of its own and shows only as consecutive generations from different agents. Responses API calls are all named Response, so the span name does not say which agent spoke. To mark handoff boundaries, add an observe wrapper per agent entry or use the framework’s RunHooks to open spans at agent boundaries. Streamed runs carry token counts only when usage is enabled on the underlying client; the OpenAI integration page covers the include_usage setting.

The integrations list shows what else attaches automatically if your app uses other libraries.

When something else fits

• Rius has no datasets, experiments, evaluators, feedback queues, Prompt Hub or playground, so keep LangSmith for those and run both backends.
• Existing LangSmith traces stay in LangSmith, because Rius cannot import them and starts from the first span you send.
• Rius is a managed service only, so a self-hosted deployment is not available.

Related