> ## Documentation Index
> Fetch the complete documentation index at: https://docs.omnia-voice.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Set up with your coding agent

> One prompt wires your repo to Omnia — through the gateway, your own provider key, OpenTelemetry, or the tracing SDK — and verifies itself.

The fastest integration is the one your coding agent does for you. Omnia
publishes a single canonical prompt that Claude Code, Cursor, or any coding
agent with repository access can follow end to end: it inspects your repo,
picks the right integration path, makes the edits, and runs the setup check to
prove the result.

```bash theme={null}
curl -fsSL https://platform.omnia-voice.com/agent-setup.md
```

Paste the fetched prompt into your agent, provide `OMNIA_API_KEY` when asked,
and read its report.

## Integration paths

The prompt has your agent pick one of the four
[integration paths](/capture/overview), based on what your repo actually
uses:

**Gateway** (your app calls an OpenAI-compatible API and can use Omnia's
catalog): points your existing client at `https://gateway.omnia-voice.com/v1`
with your Omnia key. Model names pass through unchanged. The agent also tags
your traffic (`X-Omnia-Tag`) so it lands as one evaluation population, and
threads a run id (`X-Omnia-Trace-Id`, or your existing W3C `traceparent`)
when your app makes several calls per run.

**Your provider key (BYOK)** (you run GPT, Claude, or Gemini and intend to keep
it): same base-URL swap, but your model doesn't change; you paste your
provider's API key into *Settings → Workspace → Provider keys*, the model name
gains a provider prefix (`anthropic/claude-sonnet-4-5`), and your provider
keeps billing you directly; Omnia bills nothing for those tokens. You get
capture, tags, caching, and fallbacks with zero model risk.

**OpenTelemetry** (your app already emits OTel traces: Vercel AI SDK
telemetry, Pydantic AI, an existing OTel SDK): no packages, no code, three
environment variables:

```bash theme={null}
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://gateway.omnia-voice.com/v1/traces
OTEL_EXPORTER_OTLP_TRACES_HEADERS="Authorization=Bearer ${OMNIA_API_KEY}"
OTEL_RESOURCE_ATTRIBUTES=omnia.tag=my-agent
```

Omnia's ingest understands the official `gen_ai.*` conventions plus the
Traceloop, Vercel `ai.*`, and OpenInference attribute dialects, and normalizes
them all into one gradeable shape.

**Tracing SDK** (no OTel yet, and your inference stays where it is):
one package, one line, standard OpenTelemetry underneath.

```bash theme={null}
npm install @omnia-voice/tracing        # Node
pip install omnia-tracing         # Python
```

```ts theme={null}
import { setup } from "@omnia-voice/tracing";
setup(); // before creating LLM clients; reads OMNIA_API_KEY + OMNIA_TAG
```

Pure-ESM Node apps skip even that line: `node --import @omnia-voice/tracing/register`.
OpenAI, Anthropic, Gemini (Python), and LangChain are captured automatically,
only libraries actually installed are instrumented. The SDK contains no
instrumentation code of its own, and its README documents the identical setup
in vanilla OTel: eject anytime, your spans don't change.

<Note>
  Whichever path the agent picks, the traffic becomes gradeable population: you
  can grade it, calibrate a judge against your grades, and run screening
  comparisons; the BYOK, OpenTelemetry, and Tracing SDK paths do all of that
  before a single inference decision changes. Model-call content is stored only
  if your workspace has request logging enabled, under your retention window;
  span structure is kept either way.
</Note>

## Verifying by hand

The same check the agent runs:

```bash theme={null}
OMNIA_API_KEY=sk_... sh -c "$(curl -fsSL https://platform.omnia-voice.com/setup.sh)"
```

It proves the key works, reports logging/traffic/grades/judge progress, and
names the one next step. It installs nothing and never stores your key. Add
`-- --no-inference` to skip the one-cent test completion.