Skip to content
RosettaAI mediation with hard contracts

Translate any merchant payload to any vendor contract.

Rosetta is the AI mediation layer for the long tail of pricing schemas. AI proposes the mapping; a deterministic compiler emits the bytes; hard validation runs before anything hits the wire; humans approve the rest.

Open the Rosetta dashboardRead the API reference

Onboard a new merchant in one call

POST /api/rosetta/ingest

Same endpoint, same request shape, every call, for the lifetime of the integration. The merchant POSTs a raw payload; Rosetta fingerprints the shape, looks up an adapter for (tenant, fingerprint, canonical_target), and returns the canonical record. No schema authoring, no SDK, no hand-mapped fields.

  • Cache hit (`stable`). Frozen mapping replays in microseconds. No LLM cost, no LLM latency.
  • First call (`auto_provisioned`). Infer schema → suggest mapping → freeze adapter → translate, all in one round-trip when confidence is high.
  • Medium confidence (`provisional`). Best-effort canonical record + a review_id so a human can approve and promote a frozen adapter.
  • Low confidence (`needs_review`). 202 Accepted, no canonical record. Rosetta refuses to guess silently.
  • Drift (`drift_detected`). Merchant changes their payload? Fingerprint diverges, the LLM-driven pipeline re-runs on the new shape, the old adapter is kept for replay, and a webhook fires.
Request
POST /api/rosetta/ingest
Authorization: Bearer <token>
Content-Type: application/json

{
  "canonical_target": "offer",
  "payload": {
    "sku": "ABC-123",
    "name": "Aurora Hoodie",
    "list_price": 79.99,
    "currency": "USD"
  }
}
Response (cache hit, ~5ms)
{
  "status": "stable",
  "adapter_id": "8b1f...",
  "fingerprint": "5e1f9943a2ccc1e3",
  "canonical_record": {
    "id": "ABC-123",
    "title": "Aurora Hoodie",
    "price": { "amount": 79.99, "currency": "USD" }
  },
  "ready": true,
  "confidence": 0.94
}

The Rosetta pipeline

Six stages. AI in the soft parts. Hard contracts at the boundary.

Rosetta puts AI in the parts of integration that benefit from it (mapping, drift detection, suggestions) and keeps deterministic code at the parts that must not fail (compile, validate, freeze).

  1. 01

    Canonical

    Built-in canonical schemas (product, offer, observation, match, action) describe the intent of a payload independent of any vendor.

  2. 02

    Plan

    A heuristic + LLM mapper proposes field-level mappings with per-field confidence and tier (heuristic, schema-guided, example-guided, freeform).

  3. 03

    Compile

    The plan is compiled into a deterministic outbound payload. Path operations and transforms are pure, same input, same bytes.

  4. 04

    Validate

    The compiled payload is checked against the vendor contract before anything goes on the wire. Hard contracts: required fields, types, allowed extras.

  5. 05

    Review

    Low-confidence plans, drift, and newly-seen fields are queued for a human approve/reject, never silently sent.

  6. 06

    Freeze

    Approved high-confidence plans are promoted to FrozenAdapters with a stable fingerprint. Drift is detected against future re-plans.

API surface

One package. Eight endpoints. Same auth as the rest of Last Price.

  • POST/api/rosetta/ingest

    Autonomous onboarding. One call: fingerprint + cache lookup + (on miss) infer + plan + auto-freeze / queue / refuse. Same shape, every call, including drift.

  • POST/api/rosetta/translate

    Full pipeline: plan + compile + validate (+ optional auto-queue for review).

  • POST/api/rosetta/plan

    Just the mapper. Returns proposed mappings with per-field confidence.

  • POST/api/rosetta/normalize

    Vendor response → canonical schema. The reverse direction.

  • POST/api/rosetta/freeze

    Promote a MappingPlan to a deterministic FrozenAdapter.

  • GET/api/rosetta/canonical-schemas

    List the built-in canonical schemas.

  • GET / POST/api/rosetta/review

    List or resolve (approve/reject) review-queue items.

  • GET/api/rosetta/health

    Service ping.

Why Rosetta is part of our strategy

Pricing is a long tail of schemas. Translation cannot be a side project.

Every merchant has a slightly different shape for a product. Every vendor has a slightly different shape for an offer. The work of getting a price from one to the other — consistently, safely, at machine speed — is the actual work. It is not glue code; it is the product.

Rosetta makes that work first-class. AI proposes mappings on the long tail. Deterministic code compiles and validates them on the hot path. Humans review what the model is unsure about. Approved adapters get frozen and fingerprinted, so drift can be detected the next time the upstream schema changes.

That is why Rosetta lives next to PCN in the dashboard, in the docs, and in the investor narrative — not as a separate product, but as one of the pillars of the platform.

Try it now

Translate, review, and freeze in your dashboard.

The Rosetta dashboard is browsable read-only without signing in. Run a translate, browse the canonical schemas, see the review queue.

Open RosettaSee it in Functions