How It Works - Aether

The problem: fragmented product data

When someone asks an AI agent to find the best price on a specific product, the agent faces a surprisingly difficult task. The information it needs - current prices, stock availability, product specifications - is spread across dozens of retailer websites, each structured differently.

A single pair of headphones might appear as three entirely different listings across three merchants. One site lists the product as "Sony WH-1000XM5", another as "Sony WH1000XM5 Wireless NC Over-Ear Headphones", and a third as "SONY Wireless Noise Cancelling Headphone WH-1000XM5 Black". The underlying product is identical, but the data isn't.

Prices are formatted inconsistently. Some merchants display prices inclusive of VAT, others don't. Sale prices may appear as separate fields, inline annotations, or only after JavaScript rendering. Availability data is similarly unreliable - a product might show as "in stock" on a category page but "available in 3-5 days" on the product detail page.

For a human browsing these sites, this is manageable. You learn to read around the inconsistencies. For an AI agent attempting to programmatically compare options and give its user a reliable answer, it's a wall. The agent either needs to build and maintain its own scraping and normalisation infrastructure for every retailer - which is expensive, fragile, and often against terms of service - or it gives a vague, hedged response and sends the user off to do the comparison themselves.

Neither outcome is good enough.

The solution: normalisation at the source

Aether sits between the agents and the retailers. It ingests product data from merchant feeds, normalises it into a single consistent schema, and serves it through a clean REST API.

The normalisation process handles the messy work:

Identity resolution - Aether uses GTINs (Global Trade Item Numbers, the barcode number on physical products) to identify when the same product appears across multiple merchants. A query for a specific GTIN returns every merchant's listing for that exact product, making true like-for-like price comparison possible.

Schema consistency - Every product in Aether follows the same data structure, regardless of which merchant it comes from. Price is always in the same format. Availability uses a fixed set of values. Category taxonomy is standardised. An agent that can read one Aether response can read them all.

Freshness tracking - Every data point carries a timestamp indicating when it was last verified. Agents can see at a glance whether a price was checked two hours ago or two days ago, and decide how much to trust it. Aether doesn't pretend stale data is fresh.

Purchase routing - Every product listing includes a direct purchase URL. When a user clicks through, the link routes via Aether's tracking so the appropriate affiliate commission is recorded. The user lands on the retailer's product page at the same price they'd find going directly.

The query-to-purchase flow

Here's what happens when an agent uses Aether to help someone find a product:

1. The user asks a question

A person asks their AI agent something like: "Where's the cheapest place to buy Sony WH-1000XM5 headphones right now?"

2. The agent queries Aether

The agent sends a structured API request:

GET /v1/products?q=sony+wh-1000xm5&category=headphones&sort=price_asc

This is a standard REST call. The agent specifies what it's looking for, how to filter the results, and how to sort them. No scraping, no browser automation, no HTML parsing.

3. Aether returns structured data

The API responds with normalised product data from every integrated merchant that stocks the item:

{
  "data": [
    {
      "name": "Sony WH-1000XM5 Wireless Headphones",
      "brand": "Sony",
      "price": { "amount": 249.00, "currency": "GBP" },
      "availability": "in_stock",
      "merchant": { "name": "Retailer A" },
      "purchase_url": "https://api.aethergraph.io/r/aeth-ra-41822"
    },
    {
      "name": "Sony WH-1000XM5 Wireless Headphones",
      "brand": "Sony",
      "price": { "amount": 279.00, "currency": "GBP" },
      "availability": "in_stock",
      "merchant": { "name": "Retailer B" },
      "purchase_url": "https://api.aethergraph.io/r/aeth-rb-55190"
    }
  ]
}

Every listing follows the same structure. The agent doesn't need to interpret or transform anything.

4. The agent presents options

The agent can now give its user a clear, direct answer: "The cheapest in-stock option is £249 from Retailer A. Retailer B has it for £279." No hedging, no "you might want to check a few sites." A concrete answer backed by real data.

5. The user clicks through

When the user chooses an option, the purchase URL redirects them to the retailer's product page. The affiliate tracking is handled invisibly. The user sees the same price and the same page they'd see arriving from a search engine or typing the URL directly. The retailer pays a commission to Aether for the referral.

Data freshness and trust

Product data goes stale. Prices change, stock sells out, sales end. Aether handles this by being explicit rather than optimistic.

Every API response includes freshness metadata - timestamps showing when each listing was last verified against the merchant's feed. This lets agents make informed decisions about how much to trust a given data point. A price confirmed two hours ago is more reliable than one last checked two days ago, and the agent can communicate that uncertainty to the user if appropriate.

Aether refreshes its data from merchant feeds on a regular cycle, prioritising high-demand categories and products with volatile pricing. The freshness timestamps mean agents are never in the dark about data quality - they can see exactly what they're working with.

What Aether does not do

It's worth being clear about boundaries. Aether does not recommend products. It doesn't rank results by "best" or apply editorial judgment. Sorting is determined entirely by the parameters in the agent's request - price, relevance, recency. The agent and its user decide what matters, not Aether.

Aether also doesn't handle the purchase itself. Once a user clicks through to a retailer, the transaction is between the user and that merchant. Aether's role ends at the redirect.

For a technical overview of the API, see the documentation.

How Aether works