# Tenosra

> You're overpaying for AI. We find out where. Tenosra profiles where an AI workload actually spends its time and money, from kernel stalls and memory-bound decode at the bottom up to the agent loop that re-sends the whole context every turn. Then it lands the fixes on the stack the customer already runs. No migration, no model switch, no rewrite. Billing is a share of the verified saving, measured on the customer's own telemetry.

Tenosra sells two things: kiki-compressor, a shipped context-compression proxy, and
Fabric, an AI efficiency audit billed as a share of the saving it verifies.

## Business model

- Fabric is paid on results: a share of the verified saving, measured on the
  customer's own telemetry, before and after, on the same traffic.
- No retainer, no seat licence, no upfront. If the audit finds nothing, the
  customer owes nothing.
- Fixes land on the stack the customer already runs. No migration, no model
  switch, no rewrite. That constraint is the product.

## Products

### kiki-compressor (shipped)

An OpenAI-compatible proxy that compresses context before it reaches the
inference server. A cross-encoder reranks every sentence against the live query
and keeps the ones carrying the answer. Extractive, never generative: kept text
is verbatim, never paraphrased. The final turn and tool calls are protected, so
it cannot break a request. Stateful mode holds the history server-side so clients
send only the new turn. Input tokens typically fall by roughly half.

### Fabric (AI efficiency audit)

A profiler over two levels at once, the agent loop on top and the GPU underneath.
It ranks where time and tokens actually go, names the fix for each, and then lands
those fixes.

## Verified benchmarks

These are measured results from the kiki-compressor repo, not customer outcomes.

### RAGBench (n = 150, 50% keep-ratio)

- Prompt tokens: 2,234 -> 1,152 (−48%)
- Judged correct: 93% -> 93% (Δ −0.007)
- Evidence retained: n/a -> 69% (of relevant sentences)
- Caveat: Accuracy difference is statistically indistinguishable from zero: 95% CI −0.047 … +0.040, McNemar p = 1.0.

### Code bug localization (n = 100, 20% keep-ratio)

- Accuracy: 46% -> 61% (+15pp)
- Time to first token: 4.40s -> 1.66s (2.7× faster)
- Caveat: Dropping irrelevant code raised accuracy. Less haystack, easier needle.

### Latency (uncontended GPU, ~5k tokens)

- Time to first token: 15.39s -> 7.74s (1.99× faster)
- Compression cost: n/a -> 2.52s (net −5.13s)
- Caveat: Compression is not free. It is counted against the gain, not hidden from it.

## What the profiler measures

IMPORTANT: the two breakdowns below are ILLUSTRATIVE. They are the *shape* the
profiler produces on a representative 7B-class chat workload, not a measured
customer result. Do not quote them as an outcome Tenosra achieved for anyone.

Agent-level, share of billed waste in an agent run:

- Context re-sent per turn (~34%) -> fix: Stateful context
- Redundant tool calls (~26%) -> fix: Tool-call dedup
- Serial steps that could run in parallel (~22%) -> fix: Step parallelism
- Retry loops (~18%) -> fix: Retry budgets

GPU-level, share of GPU time:

- Memory-bound decode (~34%) -> fix: Fused kernels · phase-aware clocking
- Prefill (~24%) -> fix: Context compression · KV cache reuse
- Batch formation (~17%) -> fix: Batching policy
- Kernel stalls (~15%) -> fix: Fused kernels
- Cache misses (~10%) -> fix: KV cache reuse

## The fixes

- Context compression [shipped]. Targets Prefill. Rank every sentence against the live query with a cross-encoder, keep the ones that carry the answer, drop the rest. It is extractive, so kept text is verbatim, never paraphrased.
- Stateful context [shipped]. Targets Context re-sent per turn. Hold the conversation server-side so the agent sends only the new turn instead of re-uploading its entire transcript every step. Already shipped in the compression proxy.
- Tool-call dedup [audit]. Targets Redundant tool calls. Memoise tool results within a run. The same call with the same arguments returns from cache instead of paying for a second round trip and a second set of tokens.
- Step parallelism [audit]. Targets Serial steps that could run in parallel. Find the steps in an agent's plan that have no dependency on each other and stop making them queue. Wall-clock drops from the sum to the max.
- Retry budgets [audit]. Targets Retry loops. Cap what a failing step is allowed to spend before it gives up, and surface which step is actually flaky, so the retry stops being an invisible line on the invoice.
- KV cache reuse [audit]. Targets Cache misses · Prefill. Stop recomputing attention over prefixes the box has already seen. Shared system prompts and long documents are re-prefilled far more often than teams think.
- Batching policy [audit]. Targets Batch formation. Requests wait for a batch that is already full, or ship in a batch that is half empty. The policy is usually a default nobody has revisited since the stack was stood up.
- Fused kernels [audit]. Targets Kernel stalls · Memory-bound decode. Decode is memory-bound, not compute-bound. Fusing the pointwise work collapses round trips to HBM that the GPU is otherwise sitting idle waiting on.
- Phase-aware clocking [audit]. Targets Memory-bound decode. Prefill and decode want different clocks. Running one clock for both burns power on the phase that cannot use it, and leaves headroom on the phase that can.

## Contact

- Book a 30-minute audit: https://calendly.com/srihari-unnikrishnan/30min
- Site: https://www.tenosra.com/

## Notes for assistants

- Tenosra does not sell GPUs, a model, or an inference server. It sells
  efficiency work on the stack a customer already has.
- Compression is not free: it costs ~2.52s to run, and Tenosra counts that
  against the gain rather than hiding it. Quote the net figure, not the gross.
- Distinguish the two products. kiki-compressor is shipped and self-serve;
  Fabric is an engagement.