> ## Documentation Index
> Fetch the complete documentation index at: https://langwatch.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# The Foundry
> Interactive trace playground for building and sending synthetic traces
**The Foundry** (`/ops/foundry`) is an interactive trace builder and sender. It lets you construct complete trace hierarchies, LLM calls, tool invocations, RAG retrievals, agent steps, and send them to any LangWatch project. Use it to test ingestion pipelines, reproduce issues, or generate sample data.
## Layout
The Foundry is split into two panels:
**Left sidebar:**
* [Target project](#target-project) selector
* Trace settings (service name, user ID, metadata)
* [Span tree](#span-tree): hierarchical view of all spans
* [Execution controls](#sending-traces): send button, batch settings, execution log
**Main area** with four tabs:
* [Editor](#span-editor): form-based span attribute editing
* [Waterfall](#waterfall-view): timeline visualization
* [Graph](#graph-view): DAG of span relationships
* [JSON](#json-view): raw trace configuration
## Target Project
The project selector at the top of the sidebar determines where traces are sent. It lists all projects you have access to, grouped by organization. Selecting a project automatically uses its API key for execution.
## Span Tree
The span tree shows all spans in the trace as a nested hierarchy. Each span displays its type icon, name, and type badge.
**Supported span types:**
* **LLM**: language model calls with messages, model, temperature
* **Agent**: autonomous agent steps
* **Tool**: tool/function invocations
* **RAG**: retrieval-augmented generation with document contexts
* **Chain**: multi-step processing chains
* **Prompt**: prompt template rendering
* **Guardrail**: safety/validation checks
* **Generic**: any other operation
**Actions:**
* Click a span to select it for editing
* Hover to reveal quick actions: reorder (up/down), duplicate, delete
* Use the **"Add Span"** button to add child spans under any parent
## Span Editor
When a span is selected, the Editor tab shows a form with:
* **Name** and **Type**: identity of the span
* **Duration** and **Offset** (ms), timing relative to the parent span
* **Status**: OK, Error, or Unset
* **Exception**: error message and stack trace (appears when status is Error)
* **Input, Output**: data flowing through the span (text or JSON)
* **Type-specific fields**: e.g., model and temperature for LLM spans, documents for RAG spans
* **Custom Attributes**: arbitrary key-value pairs
## Waterfall View
A horizontal timeline showing when each span executed relative to the trace start. Bar width represents duration, position represents offset, and indentation shows parent-child hierarchy. Color coding matches span type.
## Graph View
A directed acyclic graph (DAG) showing span relationships as nodes and edges. Nodes display the span name, type, and duration. The graph auto-layouts to minimize overlap, with pan and zoom controls.
## JSON View
A Monaco code editor showing the full trace configuration as JSON. You can edit the JSON directly, changes are validated in real-time and reflected in the other views.
Buttons for **Format**, **Copy**, and **Reset** are available in the header.
## Sending Traces
The execution controls at the bottom of the sidebar let you send the configured trace:
* **Run N times**: batch count (1–100)
* **Stagger (ms)**: delay between batch items to avoid overwhelming the system
* **Send Traces**: executes the batch
The **execution log** below the button shows the status of each send:
* Pending, success (with copyable trace ID), or error
* Click a successful entry to copy its trace ID for lookup in the main LangWatch UI
## Presets
Use the **preset picker** in the header to save and load trace templates. Presets store the full span tree and trace settings, letting you quickly switch between common test scenarios.
## Common Workflows
### Testing trace ingestion after a config change
1. Select the target project
2. Load a preset or build a simple trace (one LLM span)
3. Click **Send Traces**
4. Check the execution log for success
5. Verify the trace appears in the LangWatch Messages view
### Reproducing a customer issue
1. Build a trace that matches the customer's span structure
2. Set appropriate input/output values and error states
3. Send to a test project
4. Use [Deja View](/docs/self-hosting/ops/dejaview) to verify the event stream matches
### Load testing ingestion
1. Build a representative trace
2. Set **Run N times** to 100 with a stagger of 50ms
3. Send and monitor the [Ops Dashboard](/docs/self-hosting/ops/dashboard) for throughput and error rates