<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by WunderCorp, Inc. on Medium]]></title>
        <description><![CDATA[Stories by WunderCorp, Inc. on Medium]]></description>
        <link>https://medium.com/@wundercorp?source=rss-cc310330d2c4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*QxlcPX-HUpOuEOIpGQN-9w.png</url>
            <title>Stories by WunderCorp, Inc. on Medium</title>
            <link>https://medium.com/@wundercorp?source=rss-cc310330d2c4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 01:24:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@wundercorp/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Building Telemio for Faster Telemetry and AI-Native Development]]></title>
            <link>https://wundercorp.medium.com/building-telemio-for-faster-telemetry-and-ai-native-development-21f6adf967ca?source=rss-cc310330d2c4------2</link>
            <guid isPermaLink="false">https://medium.com/p/21f6adf967ca</guid>
            <category><![CDATA[otlp]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[poppy]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[opentelemetry]]></category>
            <dc:creator><![CDATA[WunderCorp, Inc.]]></dc:creator>
            <pubDate>Sat, 14 Nov 2026 23:01:49 GMT</pubDate>
            <atom:updated>2026-11-14T23:16:03.854Z</atom:updated>
            <content:encoded><![CDATA[<h3><em>What we learned from Rust benchmarks, why we added Protobuf to our TypeScript SDK, and how we’re making observability easier for developers and AI agents to use.</em></h3><p><strong>By the Telemio Engineering Team · November 2026</strong></p><p>Observability has two problems that are easy to underestimate.</p><p>The first is performance. Collecting telemetry is straightforward until applications begin generating enough spans, logs, and metrics that the collection system itself becomes a bottleneck.</p><p>The second is integration. Developers shouldn’t need to adopt a completely different instrumentation model for every language or teach each AI coding agent how their observability platform works.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oe8bAyTLq3Er6EjvjOm41A.jpeg" /></figure><p>We’ve been working on both problems in <a href="https://telemio.sh/">Telemio</a>, our OpenTelemetry-based observability platform for applications, infrastructure, and AI-agent runtimes.</p><p>Over the past several development cycles, we’ve moved the production telemetry engine toward Rust, released an updated TypeScript SDK with optional OTLP Protobuf transport, expanded our multi-language documentation, and added the first layer of Personal Agent Protocol discovery.</p><p>We also ran new benchmarks. The results are worth examining, particularly because they show how workload size changes the relative performance of our two storage implementations.</p><h3>Why we started moving telemetry processing to Rust</h3><p>Our original telemetry backend used Node.js for receiving, storing, and querying OpenTelemetry data.</p><p>Node.js remains useful for API development, authentication, integrations, and control-plane workflows. But we wanted to test whether a native engine could provide more predictable throughput for the storage and query operations that grow with telemetry volume.</p><p>Rather than immediately replace the entire application, we built a Rust-backed telemetry engine alongside the existing Node implementation.</p><p>This separation lets us compare equivalent workloads while retaining the application APIs and surrounding infrastructure.</p><p>It also creates an important distinction in our benchmarks: some tests measure the storage engine directly, while others measure an HTTP ingestion path that still includes Node.js.</p><p>Those measurements answer different questions.</p><h3>The first result: 13.3× higher HTTP ingestion throughput</h3><p>On November 7, 2026, we ran a local OTLP/HTTP ingestion comparison using a workload of 20,000 spans.</p><p>The Rust-backed configuration acknowledged substantially more spans per second than the Legacy Node configuration.</p><p>MetricLegacy NodeRust-backedAcknowledged throughput1,829 spans/sec24,305 spans/secHTTP request p95852.70 ms34.96 msFailed requests00Persisted spans, including warmup22,00022,000</p><p>That is approximately <strong>13.3× higher acknowledged ingestion throughput</strong> in this particular test.</p><p>It was an encouraging result, but it needs context.</p><p>We ran one measured trial per engine. The Rust-backed path still included Node.js as the HTTP receiver. The result also doesn’t establish crash durability, historical query parity, or full-process memory efficiency.</p><p>It demonstrates a meaningful advantage for one local workload, not a universal 13.3× performance guarantee.</p><h3>What happened when we increased the dataset</h3><p>We subsequently ran a separate storage-engine benchmark with five repetitions per engine, using batches of 250 spans.</p><p>First, we tested 10,000 spans.</p><p>Then we increased the workload to 50,000 spans without changing the batch size.</p><p>Here are the median results:</p><p>WorkloadLegacy Node throughputRust throughputRust advantage10,000 spans22,803 spans/sec36,176 spans/sec<strong>1.59×</strong>50,000 spans4,742 spans/sec38,824 spans/sec<strong>8.19×</strong></p><p>The 50,000-span workload was particularly interesting.</p><p>Legacy Node’s measured throughput fell sharply as the dataset grew. Rust remained around 36,000–40,000 spans per second across the five runs.</p><p>The larger workload also produced lower reported query latency for Rust:</p><h3>50K Workload</h3><p><strong>Ingestion throughput</strong></p><ul><li><strong>Legacy Node.js:</strong> 4,742 spans/sec</li><li><strong>Rust:</strong> 38,824 spans/sec</li><li><strong>Result:</strong> Rust achieved <strong>8.2× higher throughput</strong>.</li></ul><p><strong>Query latency (p95)</strong></p><ul><li><strong>Legacy Node.js:</strong> 111.05 ms</li><li><strong>Rust:</strong> 81.73 ms</li><li><strong>Result:</strong> Rust reduced query latency by <strong>26.4%</strong>.</li></ul><p><strong>Disk usage</strong></p><ul><li><strong>Legacy Node.js:</strong> 24,442,922 bytes</li><li><strong>Rust:</strong> 24,442,922 bytes</li><li><strong>Result:</strong> Identical reported disk usage.</li></ul><p>At 50K spans, Rust delivered approximately <strong>8.19× the ingestion throughput</strong> and <strong>26.4% lower reported query p95 latency</strong>.</p><p>The throughput advantage increased with this workload size. That suggests there may be a scaling bottleneck in our legacy storage path, but we haven’t isolated its exact cause.</p><p>The query measurements also use a small timing sample, so we aren’t treating those p95 values as production-grade tail-latency measurements.</p><h3>Why the 13.3× and 8.19× results differ</h3><p>It’s tempting to put all the numbers on one chart and treat them as directly comparable.</p><p>That would be misleading.</p><p>The earlier 13.3× test included HTTP request handling and ingestion behavior. The newer 1.59× and 8.19× results measure the storage-engine interface under different dataset sizes.</p><p>We view them as complementary evidence.</p><p>One test helps identify end-to-end ingestion bottlenecks. The other helps us understand how storage performance changes as the workload grows.</p><p>The next step is to repeat the HTTP benchmark across several runs, profile the legacy path, and test larger datasets while checking record counts, query equivalence, CPU usage, and memory consumption.</p><h3>We also released @telemio/sdk 0.2.0</h3><p>Engine performance matters, but improving the backend shouldn’t require application developers to change their instrumentation code.</p><p>That principle guided our latest SDK release.</p><p>We published <a href="https://www.npmjs.com/package/@telemio/sdk">@telemio/sdk 0.2.0</a> with optional <strong>OTLP/HTTP Protobuf</strong> support for traces, metrics, and logs.</p><p>Existing integrations continue using JSON by default.</p><p>Applications can opt into the binary format through a configuration option:</p><pre>import { createTelemio } from &quot;@telemio/sdk&quot;;</pre><pre>const telemio = createTelemio({<br>  serviceName: &quot;checkout-api&quot;,<br>  apiKey: process.env.TELEMIO_API_KEY,<br>  otlpProtocol: &quot;http/protobuf&quot;,<br>});</pre><p>We kept the existing public API and package name, so developers don’t have to migrate to a new SDK to try Protobuf.</p><p>Feature flags, custom events, and runtime-management requests retain their existing JSON behavior.</p><p>The goal is straightforward: support a standard binary telemetry encoding without making transport changes disruptive.</p><p>Protobuf is a wire-format capability, not a promise that every workload will become faster automatically. We still need dedicated SDK benchmarks to quantify serialization cost, payload size, and transport performance.</p><h3>One telemetry protocol, multiple languages</h3><p>The next improvement was documentation.</p><p>Telemio already supports OpenTelemetry-based instrumentation, but documentation organized only around individual frameworks can make cross-language integration harder to discover.</p><p>We added a <a href="https://telemio.sh/docs/guides/otlp-protobuf.html">multi-language OTLP Protobuf guide</a> with examples for TypeScript, Python, Go, and Rust.</p><p>The guide uses the existing documentation language tabs and includes the exporter configuration developers need to send telemetry.</p><p>There’s an important implementation distinction:</p><ul><li>TypeScript uses our first-party @telemio/sdk.</li><li>Python, Go, and Rust use their established OpenTelemetry libraries and exporters.</li><li>All of them can use the same OTLP Protobuf message contract.</li></ul><p>We also added a repeatable documentation example generator to the repository, so shared examples can be maintained together rather than edited independently across several pages.</p><p>We aren’t claiming to have published native Telemio SDKs for all four languages. Shared Protobuf definitions give us a compatible data contract; complete language SDKs still require runtime-specific instrumentation, authentication, packaging, and testing.</p><p>That work can happen incrementally without changing the npm distribution of our existing SDK.</p><h3>Making Telemio discoverable to AI agents</h3><p>Telemetry is increasingly useful outside a traditional monitoring dashboard.</p><p>A coding agent investigating a production issue may need to find an existing trace, inspect errors around a deployment, or correlate a runtime session with its tool calls.</p><p>But before an agent can use any of those capabilities, it needs to know what services exist and how to access them.</p><p>We’ve been building out that discovery layer.</p><h3>Personal Agent Protocol discovery</h3><p>We added an initial implementation of the <a href="https://personalagentprotocol.org/docs/1.0/spec">Personal Agent Protocol</a>, also known as Poppy.</p><p>The public discovery surfaces include:</p><ul><li><a href="https://telemio.sh/.well-known/poppy.json">/.well-known/poppy.json</a>, for protocol discovery.</li><li><a href="https://telemio.sh/poppy/capabilities.json">/poppy/capabilities.json</a>, describing public integration capabilities.</li><li>A read-only OpenAPI description for public setup information.</li></ul><p>The immediate use case is helping an agent discover Telemio, understand its integration options, and locate relevant documentation.</p><p>This doesn’t automatically give an agent access to private telemetry.</p><p>Workspace data remains protected by Telemio’s existing authentication and scoped permissions. Full Poppy account delegation and authenticated sessions require additional identity verification, consent, and authorization work.</p><h3>A general-purpose agent skill</h3><p>We’ve also prepared a skill.md document for Telemio.</p><p>Unlike the Poppy discovery metadata, this is intended to be practical guidance that a coding agent can read before working with the platform.</p><p>It explains how to select an integration, instrument an application, configure credentials, connect through MCP where authorized, and verify telemetry.</p><p>The planned public entry point is:</p><p><a href="https://telemio.sh/skill.md">https://telemio.sh/skill.md</a></p><p>We see these mechanisms as complementary.</p><p>Poppy helps agents discover a service. The skill document explains how to use it. MCP provides an existing way to access authorized workspace context.</p><p>Discovery and permission are separate concerns, and we intend to keep them that way.</p><h3>Making performance results easier to inspect</h3><p>We’ve also added a local benchmark-report viewer to the Telemio console.</p><p>The current workflow runs benchmark scripts outside production, exports a JSON report, and imports that report into the console for comparison.</p><p>That’s deliberate.</p><p>An observability platform shouldn’t start an expensive load test against customer workloads simply because someone clicks a button in a dashboard.</p><p>The current viewer is a reporting tool rather than a hosted benchmark execution service.</p><p>Our next iteration will focus on preserving historical results, comparing releases, and making regressions easier to identify.</p><p>For now, our repeatable engine benchmark is useful for comparing a defined workload, but it is not a substitute for production load testing.</p><h3>What we’re working on next</h3><p>The recent results give us a clearer direction.</p><p>We want to profile the legacy storage bottleneck, validate larger Rust workloads, strengthen query and historical-record parity checks, and make benchmark methodology easier to reproduce.</p><p>On the developer side, we plan to expand runtime compatibility testing and continue toward more native language integrations where they provide a real advantage over existing OpenTelemetry tooling.</p><p>For AI agents, the priority is authenticated access with explicit workspace permissions, not simply adding more discovery metadata.</p><p>These efforts share a practical goal: make telemetry easier to collect, faster to process, and more useful inside the tools developers already use.</p><h3>Try Telemio</h3><p>If you’re instrumenting an application or giving a coding agent access to production context, you can explore the current implementation here:</p><p><a href="https://telemio.sh/"><strong>Telemio</strong></a> · <a href="https://telemio.sh/docs/">Developer documentation</a> · <a href="https://telemio.sh/docs/guides/otlp-protobuf.html">Multi-language Protobuf examples</a> · <a href="https://www.npmjs.com/package/@telemio/sdk">TypeScript SDK on npm</a></p><p>We’ll continue publishing benchmark results with their workloads and limitations, including cases where an optimization doesn’t behave as expected.</p><p>For us, that’s the useful way to measure progress: repeatable results, interoperable instrumentation, and fewer obstacles between a developer and the telemetry they need.</p><p><em>Telemio is a product of WunderCorp, Inc.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=21f6adf967ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A 13.3× Leap in Telemetry Ingestion via Telemio, and Why It Matters]]></title>
            <link>https://wundercorp.medium.com/a-13-3-leap-in-telemetry-ingestion-via-telemio-and-why-it-matters-b9213a5bab19?source=rss-cc310330d2c4------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9213a5bab19</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[agent-observability]]></category>
            <category><![CDATA[telemetry]]></category>
            <category><![CDATA[llm-observability]]></category>
            <category><![CDATA[observability]]></category>
            <dc:creator><![CDATA[WunderCorp, Inc.]]></dc:creator>
            <pubDate>Sat, 07 Nov 2026 21:16:36 GMT</pubDate>
            <atom:updated>2026-11-07T21:36:41.650Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>How Telemio’s Rust-backed telemetry engine is creating more headroom for modern applications, AI agents, and the teams responsible for keeping them running.</strong></blockquote><p><em>By Telemio Engineering · November 7, 2026 · 6-minute read</em></p><p>Every application tells a story through its telemetry.</p><p>A slow database query, a failed payment, an unexpected deployment regression, or an AI agent making repeated tool calls — each leaves behind signals that help engineering teams understand what happened.</p><p>But as applications become more distributed, those signals multiply.</p><p>A single user request can produce traces across several services, logs from multiple runtimes, database activity, infrastructure metrics, and application events. AI-powered systems introduce another dimension: model calls, tool execution, retries, and agent workflows.</p><p>The challenge is no longer simply collecting telemetry.</p><p><strong>It’s building an observability system that can keep up with the software it’s observing.</strong></p><p>That’s why we’ve been investing in Telemio’s telemetry engine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cpT8FfaCmdRbwKWcTUUbTg.png" /></figure><p>And our latest local benchmark shows a promising result: <strong>13.3× higher acknowledged ingestion throughput with our Rust-backed engine compared with our previous Node-based storage path.</strong></p><p>Let’s unpack what that means.</p><h3>Why telemetry performance matters</h3><p>Observability depends on a continuous flow of information.</p><p>When your application produces an event, that information has to travel through a telemetry pipeline before it becomes useful to your team.</p><p>In simplified terms:</p><p><strong>Application → OpenTelemetry → Ingestion → Storage → Investigation</strong></p><p>Every stage introduces work.</p><p>Telemetry must be received, decoded, associated with the right services and resources, processed, stored, and made available for querying.</p><p>As traffic grows, ingestion can become a bottleneck.</p><p>A healthy system should have enough capacity to handle normal application traffic while retaining headroom for sudden bursts, precisely when telemetry can be most valuable.</p><p>Imagine a deployment introduces an unexpected error across dozens of services. At that moment, your application may generate more telemetry than usual. You want your observability infrastructure to handle the additional load without becoming another operational problem.</p><p>This is why throughput and ingestion latency matter.</p><p>They aren’t the entire story of observability performance, but they form an important part of its foundation.</p><h3>What we changed</h3><p>Telemio is OpenTelemetry-native. We want engineering teams to instrument their applications using open standards rather than adopting a proprietary telemetry format.</p><p>We also want the platform to connect signals to the context that makes them useful: services, deployments, dependencies, sessions, and agent runs.</p><p>To support this, we’ve introduced a Rust-backed telemetry storage and query engine.</p><p>Our existing Node application continues to manage responsibilities such as authentication, HTTP ingestion, workspace logic, and application APIs. Rust handles the new telemetry persistence and query path.</p><p>That distinction matters: <strong>we didn’t replace our entire backend with Rust.</strong></p><p>We introduced a specialized engine for work that benefits from tighter control over data structures, memory, and I/O.</p><p>The architecture gives us a foundation for further improvements without asking customers to change how they instrument their applications.</p><h3>The results: 13.3× higher ingestion throughput</h3><p>We compared Telemio’s Legacy Node and Rust-backed implementations using the same local OTLP/HTTP JSON workload.</p><p>Each engine received 20,000 measured spans, using 100 spans per request and eight concurrent requests.</p><p>Here’s what we observed:</p><p>Acknowledged throughput</p><ul><li>Legacy Node: 1,829 spans/sec</li><li>Rust-backed: 24,305 spans/sec</li></ul><p>HTTP request p95 latency</p><ul><li>Legacy Node: 852.7 ms</li><li>Rust-backed: 34.96 ms</li></ul><p>Stored records, including warmup</p><ul><li>Legacy Node: 22,000</li><li>Rust-backed: 22,000</li></ul><p>Both implementations acknowledged the measured workload without request failures. A separate post-run check counted 22,000 stored records for each engine, including warmup traffic.</p><p>These are encouraging results. They suggest the Rust-backed path can substantially reduce an important ingestion bottleneck.</p><p>But there’s an important qualification: this was one local trial per engine, not a statistically established production performance advantage.</p><p>The benchmark measures end-to-end HTTP acknowledgement through Telemio’s Node ingress and selected storage path. It does not independently prove crash durability, sustained production throughput, or faster investigations.</p><p>We believe performance claims should be accompanied by the methodology needed to evaluate them.</p><h3>What does this mean for Telemio users?</h3><p>A performance improvement inside an observability engine may sound like an infrastructure detail.</p><p>Its potential benefits, however, reach much further.</p><h3>1. More room for your applications to grow</h3><p>As services, customers, and integrations grow, telemetry volume often grows with them.</p><p>Greater ingestion capacity can provide additional headroom before the telemetry pipeline becomes saturated.</p><p>For engineering teams, that creates a stronger foundation for expanding instrumentation across APIs, background workers, mobile applications, and distributed systems.</p><p>Rather than treating every new source of telemetry as an immediate capacity concern, teams can build on a pipeline designed to handle larger volumes of operational signals.</p><h3>2. Better resilience during telemetry bursts</h3><p>Production incidents rarely arrive at convenient times.</p><p>A failing dependency, aggressive retry loop, or unusual traffic spike can produce a sudden increase in traces and logs.</p><p>Additional ingestion headroom can help absorb such bursts and reduce pressure on queues and processing stages.</p><p>That doesn’t guarantee zero data loss. Durability, backpressure, and failure recovery must be validated separately, but it gives us an important performance foundation to build on.</p><p>The goal is simple: when applications become noisy, observability should remain dependable.</p><h3>3. A stronger foundation for faster troubleshooting</h3><p>Telemetry is most useful when it can be investigated while the problem is still happening.</p><p>Lower ingestion response latency is one component of that experience.</p><p>Our benchmark showed substantially lower HTTP request latency with the Rust-backed engine. It did not directly measure the full time from an application event to a searchable result.</p><p>That’s an important next measurement.</p><p>Ultimately, we’re building toward an experience where developers can move naturally from a failing request to its traces, related logs, deployment context, and dependencies without piecing together disconnected systems.</p><h3>4. Room for richer AI-agent observability</h3><p>Modern software increasingly includes AI agents that call tools, access databases, interact with APIs, and perform multi-step tasks.</p><p>Understanding these systems means observing more than the model’s final response.</p><p>Teams may need to examine execution paths, tool calls, retries, latency, and their relationship to the surrounding application.</p><p>That creates more connected signals to process.</p><p>A higher-capacity telemetry engine can help provide the infrastructure needed for richer agent observability, while Telemio’s context model helps make those signals meaningful.</p><p>The benefit isn’t simply storing more events. It’s making more of the application and agent workflow available for investigation.</p><h3>5. A path toward greater infrastructure efficiency</h3><p>Performance and efficiency are connected, but they’re not identical.</p><p>Processing more telemetry in a given amount of time may create opportunities to reduce infrastructure costs or support larger workloads.</p><p>We haven’t yet established a verified production cost-per-million-spans improvement, and our early memory measurements don’t include the combined resource usage of every process.</p><p>Those are important benchmarks still ahead.</p><h3>Why we’re publishing the methodology</h3><p>Benchmark numbers are easy to quote. They’re harder to interpret.</p><p>A result depends on the workload, hardware, concurrency, payload size, implementation, and what counts as a successful operation.</p><p>For this comparison, we used a local Apple M5 Max system, OTLP/HTTP JSON with ten attributes per span, and isolated engine configurations.</p><p>We also checked stored-record counts after the test rather than relying exclusively on HTTP acknowledgements.</p><p>There are several things we still want to establish:</p><ul><li>Repeated measurements and statistical variation</li><li>Larger, sustained ingestion workloads</li><li>CPU and combined process-memory efficiency</li><li>Crash recovery and durable persistence</li><li>Query performance under concurrent ingestion</li><li>Equivalent, reproducible comparisons against other observability systems</li></ul><p>Our earlier storage/query microbenchmarks also showed that performance varies by workload size. Rust performed better in the 10,000-span scenario, while Legacy Node was faster on some smaller-workload measurements.</p><p>That’s why we don’t consider a single multiplier a universal performance promise.</p><p><strong>The purpose of benchmarking is to understand system behavior, not simply produce the largest number.</strong></p><p>We’re making our benchmark data and reproduction procedures available so others can evaluate the findings and challenge our assumptions.</p><h3>What’s next for the telemetry engine?</h3><p>The Rust-backed engine is a step in a broader engineering effort.</p><p>We’re continuing to work on the parts of observability that matter as systems become larger and more complex: ingestion, persistence, query execution, context propagation, and operational reliability.</p><p>Native Rust OTLP processing, more comprehensive durability testing, and larger-scale comparative benchmarks are natural areas for further investigation.</p><p>We’re also validating the new engine’s deployment and recovery behavior before treating it as a production-ready replacement for every existing workload.</p><p>Performance improvements need to survive real infrastructure, not just local benchmarks.</p><h3>The bigger picture</h3><p>The reason we’re excited about this work isn’t simply that one benchmark got faster.</p><p>It’s what additional capacity makes possible.</p><p>More services can produce telemetry. More application behavior can be captured. Richer context can remain connected. Engineering teams can investigate increasingly complex systems without having to think about every internal detail of the observability pipeline.</p><p>That’s the direction we’re building toward with Telemio.</p><p><strong>A high-performance telemetry foundation that helps teams spend less time managing observability infrastructure and more time understanding their software.</strong></p><p>Our latest benchmark is a promising step in our journey to create a scalable and more affordable telemetry platform.</p><p>And we’re going to keep measuring.</p><p><strong>Explore the benchmarks</strong></p><p>See the raw measurements, methodology, and reproduction instructions at <a href="https://telemio.sh/benchmarks/">telemio.sh/benchmarks</a>.</p><p><em>Benchmark disclosure: Results reflect one local A/B trial of Telemio’s Node-based and Rust-backed storage paths on November 7, 2026. Throughput represents HTTP-acknowledged spans per second. Results should not be interpreted as production guarantees or direct comparisons against other vendors.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9213a5bab19" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>