HiveWidget. The Drop-In that signs every LLM response.
Any model. Any provider. One line.

XCALIBUR is the platform. CCACW is the pipeline. AmpliHive is the widget that delivers it.

One umbrella, one pipeline, five tools. Each tool answers one question a human actually asks. No marketing words you have to translate.

smsh is the tier name. Each tier turns on more of the tools.

smsh is not a separate product — it is the service level. Think of it like card tiers. Same card, different included features.

A sidecar, not a pipe.

HiveWidget does not route your inference. It does not see your provider key. It does not change your latency budget. It sits next to your LLM call, hashes the inputs, runs five fast stages, and returns a signed certificate plus an enriched payload. Your customer’s data path stays exactly where it is. The only thing that changes is that every response is now provably yours, provably untampered, and provably attributed.

What happens between your LLM call and the cert.

Total round-trip is ~6ms p95 plus the ML-DSA-65 sign (~60ms). Off your critical path. The customer’s LLM latency story is unchanged.

prompt_hash     "sha256:f8a3\u20269c1d"
response_sha256 "sha256:b27e\u202641a8"
// re-derive from text \u2192 byte-identical

tokens_in            119
tokens_out           26
token_reduction_pct  78.15

enrichment_sha256  "sha256:97c4\u2026a0b1"
confidence         0.87
corpus_hits_count  12

amplihive_overhead_p50  4.47 ms
amplihive_overhead_p95  6.05 ms
mldsa65_sign_ms         59.76
mldsa65_verify_ms       16.76

writeback.id      8129
writeback.kind    "signed_response"
// future AMPLIFY draws from this

Why this is a homerun, not a feature.

Most “trust” layers ship one of these. HiveWidget ships eight, signed under the same cert, in the same call.

What it does in prod, today.

Re-derivable. Hit POST /v1/amplify/bench against hivemorph.onrender.com and watch.

What’s inside the signed payload.

Everything that matters is signed. Tamper with any field below and verify returns signature_valid: false.

Three ways to ship it. Same cert at the end.

Copy// JS / TS — split mode (most common)
import OpenAI from "openai";
import { AmpliHive } from "@hivery/amplihive";

const llm  = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const hive = new AmpliHive({
  tenantDid: "did:hive:acme",
  apiKey:    process.env.AMPLIHIVE_API_KEY,
  partnerId: "fireworks",                 // optional, bound into cert
});

const prompt = "Draft a 3-clause SaaS indemnity.";
const r = await llm.chat.completions.create({
  model: "claude_sonnet_4_6",
  messages: [{ role: "user", content: prompt }],
});
const text = r.choices[0].message.content;

const cert = await hive.sign({ prompt, response: text });
//
// cert.certificate.alg                   \u2192 "ML-DSA-65"
// cert.certificate.payload.tenant_did    \u2192 "did:hive:acme"
// cert.certificate.payload.partner_id    \u2192 "fireworks"
// cert.compression.token_reduction_pct   \u2192 78.15  (when dense)
// cert.stages.{compile,compress,amplify,certify,writeback}

Copy# Python — split mode
import openai
from amplihive import AmpliHive

hive = AmpliHive(
    tenant_did="did:hive:acme",
    api_key=os.environ["AMPLIHIVE_API_KEY"],
    partner_id="cloudflare",          # optional, bound into cert
)

prompt = "Summarize this MRI report at the patient level."
r = openai.chat.completions.create(
    model="gpt_5_5",
    messages=[{"role": "user", "content": prompt}],
)
text = r.choices[0].message.content

cert = hive.sign(prompt=prompt, response=text)
# cert.certificate.alg                 \u2192 "ML-DSA-65"
# cert.certificate.payload.partner_id  \u2192 "cloudflare"
# cert.compression                     \u2192 {"tokens_in": ..., "tokens_out": ..., "token_reduction_pct": ...}

Copy# Python — HiveCompute mode (tier-routed, USDC-settled)
from amplihive import HiveCompute

hive = HiveCompute(
    tenant_did="did:hive:acme",
    api_key=os.environ["AMPLIHIVE_API_KEY"],
    wallet_key=os.environ["BASE_WALLET_KEY"],   # pays 0.02 USDC per call
)

# tier="T1_STANDARD" picks cheapest qualifying model (Claude Sonnet 4.6 today)
# tier="T2_HIGH" routes to GPT-5.5 / Opus 4.7 / Gemini 3.1 Pro
result = hive.complete(
    prompt="Audit this 1099 for ALCOA compliance.",
    tier="T2_HIGH",
    partner_id="alcoa-agentguard",
)

# result.text                          \u2192 the response
# result.model_used                    \u2192 "claude_opus_4_7"
# result.cert.payload.tenant_did       \u2192 "did:hive:acme"
# result.cert.payload.counterparty_did \u2192 "did:eth:0x..."
# result.cert.payload.price_atomic     \u2192 20000  (0.02 USDC)
# result.cert.alg                      \u2192 "ML-DSA-65"

Provider-agnostic. By design.

The widget extracts response text from any standard shape and signs whatever you handed it. Bring your provider, keep your provider key, keep your latency budget.

Hard-core models. Three tiers. No filler.

The widget signs any provider you bring. When you route through HiveCompute, you get tier-based selection across seven frontier models from OpenAI, Anthropic, and Google. No open-weights filler, no random Llama forks, no gimmicks. Tier T0 for classification, T1 for standard agent work, T2 for audit-grade reasoning. Same signed cert at every tier.

Bring your own provider key in split mode and the widget never sees it. Route through HiveCompute and we pick the cheapest model that clears your tier, signed under ML-DSA-65, settled in USDC on Base.

Three buyers. One widget.

The questions we keep getting.