# Telemio > Telemio is an OpenTelemetry-first observability product for services, browsers, native/mobile apps, infrastructure, and agentic runtimes. It accepts standard telemetry and adds a lightweight first-party JavaScript/TypeScript SDK for explicit application and agent context. Use these files when you need to instrument a repository or explain how Telemio fits into an existing telemetry stack. ## Start here - [Repository setup guide](https://telemio.sh/agent/setup.md): instructions for a coding agent that needs to instrument an existing codebase. - [OpenTelemetry guide](https://telemio.sh/agent/opentelemetry.md): endpoint, service identity, runtime strategy, signal, and privacy guidance. - [JavaScript/TypeScript SDK](https://telemio.sh/agent/sdk.md): install and use the published `@telemio/sdk` for manual spans, logs, metrics, events, agent telemetry, feature flags, and experiments. - [Native/mobile guide](https://telemio.sh/agent/native-mobile.md): Swift/iOS, Android/Kotlin/Java, React Native, client-safe credentials, lifecycle, and trace propagation. - [Java/JVM guide](https://telemio.sh/agent/jvm.md): Java agent, JVM runtime context, OTLP export, and manual business spans. - [Agentic runtime guide](https://telemio.sh/agent/agentic-runtimes.md): model calls, tools, MCP, retrieval, handoffs, durable workflows, multi-agent orchestration, and metadata-first capture. - [Coding-agent runtimes](https://telemio.sh/agent/coding-agents.md): Claude Code, Codex, Hermes, Loki, Gemini CLI, Copilot CLI, runtime auto-detection, and privacy-first OTLP setup. - [Polyglot runtimes](https://telemio.sh/agent/polyglot-runtimes.md): .NET/C#, PHP, Ruby, Rust, C/C++, Erlang/Elixir, Python, Go, Node.js, and runtime-neutral OTLP guidance. - [Serverless and edge](https://telemio.sh/agent/serverless-edge.md): Lambda, Functions, Cloud Run, Vercel, Cloudflare Workers, Netlify, Deno, Bun, and ephemeral export rules. - [Collector](https://telemio.sh/agent/collector.md): gateway and local Collector patterns. - [Kubernetes](https://telemio.sh/agent/kubernetes.md): OpenTelemetry Operator, Collector, auto-injection, Jobs/CronJobs, and deployment tooling. - [Messaging](https://telemio.sh/agent/messaging.md): queues, brokers, context propagation, span links, retries, and async workers. - [Desktop](https://telemio.sh/agent/desktop.md): Electron, Tauri, and native desktop clients. - [GPU and inference](https://telemio.sh/agent/gpu-inference.md): vLLM, TGI, Triton, Ollama, Ray Serve, KServe, GPU metrics, and model-serving latency. - [Profiles](https://telemio.sh/agent/profiles.md): profile correlation and the current OpenTelemetry Profiles posture. - [Client-safe ingestion](https://telemio.sh/agent/client-ingest.md): publishable browser/mobile/desktop ingest keys, restrictions, and budgets. - [Runtime sessions](https://telemio.sh/agent/runtime-sessions.md): universal lifecycle identity, short-lived runtime tokens, parent/child runtimes, and console deep links. - [MCP workspace companion](https://telemio.sh/agent/mcp.md): workspace-scoped agent/harness access for querying telemetry, inspecting runtimes, creating dashboards, discovering integration setup paths, and returning console deep links. - [Full agent reference](https://telemio.sh/llms-full.txt): consolidated product and setup context. ## Install CLI: ```bash npm i -g telemio ``` JavaScript/TypeScript SDK: ```bash npm i @telemio/sdk ``` The CLI command is `telemio`. The SDK is published at https://www.npmjs.com/package/@telemio/sdk. ## Runtime coverage strategy Use the runtime's standard OpenTelemetry ecosystem wherever possible: - Node.js/TypeScript services and workers: OpenTelemetry auto-instrumentation; `@telemio/sdk` for explicit trusted-runtime context. - Java/JVM: OpenTelemetry Java agent or existing Java/Spring instrumentation. - Python, Go, .NET/C#, PHP, Ruby, Rust, C/C++, Erlang/Elixir and other services: standard OpenTelemetry SDK/auto-instrumentation, zero-code instrumentation, or eBPF where appropriate. - Serverless/edge: Lambda, Functions, Cloud Run, Vercel, Cloudflare Workers, Netlify, Deno, and Bun require lifecycle-aware flush/export behavior. - Kubernetes: prefer the OpenTelemetry Operator plus Collector for auto-injection, metadata enrichment, and controlled egress. - Messaging: propagate W3C trace context through queues and use span links for fan-in/batch/resume patterns. - Desktop: treat Electron/Tauri/native desktop as distributed clients and use client-safe credentials or a trusted gateway. - GPU/inference: combine model-serving traces with GPU/runtime metrics and avoid raw model content by default. - Swift/iOS: OpenTelemetry Swift/mobile instrumentation; preserve app/release/session context. - Android/Kotlin/Java: OpenTelemetry Android/mobile instrumentation; preserve lifecycle, network, crash/ANR, session, and performance context where supported. - Browser/React Native: use client-safe telemetry collection; never embed privileged server credentials. - Agentic runtimes: instrument orchestration plus model, tool, MCP, retrieval, handoff, retry, and durable/background workflow boundaries using current OpenTelemetry GenAI semantics where applicable. ## Preferred instrumentation order 1. Detect the real runtime boundaries in the repository. 2. Reuse existing OpenTelemetry and prefer standard auto/zero-code instrumentation. 3. Set `service.name`, environment, and release/build identity consistently. 4. Preserve trace context across services, queues, browser/mobile requests, and agent handoffs where possible. 5. Add manual spans or events only for business or agent operations that auto-instrumentation cannot name well. 6. Keep credentials, authorization data, payment data, prompt/tool payloads, and sensitive content out of telemetry. 7. Run the repository's tests, builds, type checks, and platform checks after instrumentation. ## Agentic runtime telemetry Treat agentic runtimes as application runtimes. Track the orchestration boundary as well as individual model and tool calls. Useful metadata includes model/provider identity, operation, agent/workflow identity, tool identity/type, token usage, cost metadata, retries, handoffs, outcome/status, and stable correlation identifiers. Telemio's agent helpers are metadata-first. Do not copy prompt, completion, retrieval, source-code, or tool payload bodies by default. For coding harnesses, start with: ```bash telemio detect agents telemio setup agent auto ``` Native setup targets include Claude Code, OpenAI Codex, Hermes Agent, Loki Agent, Gemini CLI, and GitHub Copilot CLI. Cursor, OpenCode, and Windsurf use a verified-native-OTEL-first, hooks-second strategy. ## Public endpoints - Product: https://telemio.sh/ - Console: https://console.telemio.sh/ - API and SDK default endpoint: https://api.telemio.sh - OTLP ingestion for trusted/server-side exporters: https://otlp.telemio.sh - MCP: https://mcp.telemio.sh ## Articles - [Observability for agentic runtimes](https://telemio.sh/articles/observability-for-agentic-runtimes.html) - [OpenTelemetry for native mobile apps](https://telemio.sh/articles/native-mobile-observability-with-opentelemetry.html) - [OpenTelemetry for AI agents](https://telemio.sh/articles/opentelemetry-for-ai-agents.html) - [Instrument a Node.js service with OpenTelemetry](https://telemio.sh/articles/instrument-nodejs-with-opentelemetry.html) - [Agent observability without storing every prompt](https://telemio.sh/articles/metadata-first-agent-observability.html)