Try a negotiation or ask your pricing analyst a follow-up
Play the seller in a demo negotiation, or ask questions about your workspace's pricing findings, from Agents or through the API.
Changelog
New capabilities and useful changes to pricing, agents and the API.
Last 4 weeks, +23% vs the 4 before
Releases each week, by category
| Week of | New | Improved | Fixed | Security | API | Design | Docs | Total |
|---|---|---|---|---|---|---|---|---|
| Nov 9 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 2 |
| Nov 2 | 7 | 7 | 4 | 1 | 5 | 0 | 0 | 24 |
| Oct 26 | 20 | 10 | 15 | 0 | 1 | 0 | 1 | 47 |
| Oct 19 | 64 | 22 | 17 | 2 | 6 | 0 | 0 | 111 |
| Oct 12 | 2 | 0 | 1 | 0 | 0 | 0 | 0 | 3 |
| Oct 5 | 17 | 7 | 4 | 0 | 2 | 0 | 0 | 30 |
| Sep 28 | 37 | 14 | 19 | 7 | 15 | 3 | 4 | 99 |
| Sep 21 | 9 | 4 | 3 | 1 | 1 | 0 | 0 | 18 |
| Sep 14 | 3 | 0 | 7 | 1 | 0 | 0 | 0 | 11 |
| Sep 7 | 4 | 3 | 2 | 0 | 2 | 0 | 0 | 11 |
| Jun 1 | 4 | 0 | 0 | 1 | 0 | 0 | 0 | 5 |
| May 25 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| May 11 | 7 | 0 | 0 | 2 | 0 | 1 | 1 | 11 |
| Apr 13 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
Every release, by category
Releases for people, for agents calling the API, or both
42 days with a release. Busiest: Oct 25, 2026 (82)
Release days: 42 days with at least one release. The table under the weekly chart lists every week.
Hover a day, or step through release days
Play the seller in a demo negotiation, or ask questions about your workspace's pricing findings, from Agents or through the API.

Choose French, Spanish, German, Portuguese, Japanese, Simplified Chinese, Korean or Arabic in Profile, Locale and display. Arabic reads right to left.
Add Last Price to Claude with one URL. The open tools work straight away, and the first tool that needs your account asks you to sign in.
Once an item is named from a photo, a PDF, a link or a few words, Last Price looks up what it sold for and what it is listed at online, prices it from those, and shows every page with its price beside the answer.
Send a barcode or a product name and Last Price asks several price sources at once: what sellers ask today, a year of price history, a 30-day outlook from two trained forecast models, and a verdict on a price you name. The new MCP tool find_product_prices sells one lookup for 0.05 USDC.
v0.11.0 makes every price show how it was reached and what kind of price it is, lets a buyer state its budget, asks for a fresh sign-in before money decisions, and keeps calls working when a pricing function fails.
Raising a spend limit or approving a purchase now needs a recent sign-in that doesn't come from your inbox.
An agent on an unclaimed sandbox key can now revoke that key itself when its work is done or the key may have leaked.
A self-registered agent can draft and test its own pricing functions, and a person's claim key can turn its workspace into a separate seller account.
Cost and margin inputs that cannot be read are refused by name, the explanation starts with the price you get, and a batch keeps pricing past an item that fails validation.
Give a rule_based function its rule, such as "cheapest competitor less 2%, never below cost, ending in .99", and it prices exactly by that rule.
A guardrail or routing policy you save is used by the very next price, within a second, instead of up to 30 seconds later.
Functions with real usage are ranked by score, the rest are listed after them unranked, and speed is scored from the latency their consumers saw.
Sellers see where their listing stands in review, and a listing that could mislead buyers is refused when it is published.
Automatic routing skips experiment assigners, breaks ties the same way on every call, and a routing policy that names a function it could never use is refused when you save it.
When the function cheapest or fastest routing picks fails while running, Last Price now tries the next function that can answer instead of returning an error.
An agent running a price experiment can look up what an arm's confidence and verdict mean before it acts, and marking notifications read never turns old ones unread again.
An unexpected failure on an API route now answers a JSON error with a code, a request id and whether to retry, instead of an HTML error page.
A min_price or max_price sent inside context, or to the keyless compute_price tool, now holds the price the same way constraints does.
A UCP quote for items in your catalog now takes each line's price from the catalog, as checkout does, instead of asking for a current price.
A buying agent can now tell Last Price its budget. It informs what Last Price expects the buyer to accept, but never reaches the pricing function, so it cannot set the price.
The market band that says what paid APIs charge per call now also reads the public directory of services paid through the Machine Payments Protocol (MPP), not only x402 catalogs.
Every price the API returns now says whether it is an estimate, a quote Last Price will honour, an asking price or a sale, so an agent never mistakes what a seller asks for what something sold for.
Next to the number, every computed price now shows the range it was picked from, what it rests on, what it cost to work out and, once your workspace has learned it, how likely a buyer is to accept at each price.
v0.10.0 makes a price check say what to do next (buy, negotiate, walk away or check more) and publishes one public list that explains every word the API answers with.
A new public manifest lists every call an agent can buy with no account, with its price and payment terms, so pay-per-call directories and tool routers can find Last Price and send agents to it.
An agent with a wallet can now buy one price verdict per call, with no account or key, and is not charged when the price cannot be judged.
An agent running in a web page can now read the price of a call and pay it with its wallet, with no account and no key.

The 402 from the paid price endpoint now describes the call for the x402 Bazaar, the index agents with a wallet search, so an agent can find Last Price and pay for a price without an account.

The homepage now leads with how an agent starts on its own, and the worked pricing example shows the whole formula.

A marketplace listing created with listing_description or pricing_info now stores both and returns them, instead of dropping them.

An agent can attach a short reason and a trace id to a call, and you see both next to the priced call on Usage.

The keyless demo now keeps the unit cost you send, and a tool tells you which argument it does not know instead of ignoring it.

The six starter tools now return their answers as data an agent can read directly, next to the usual text.
v0.9.0 lets an agent run on Last Price from start to finish with no person involved: it can lift its own sandbox, send email, run helper agents and hand out short-lived keys. Every computed price now comes with a check link, receipt exports are signed, and MCP clients get a shorter tool list by default.

An API key can now create a narrower child key that expires within a day, for a helper or a single job, and revoke it again with no person involved.

JSON and CSV receipt exports can carry a signature made with the same key as signed quotes, and a public verify call checks one receipt or a whole page without an account.

Two new MCP tools let an agent promote a model that passed shadow pricing and stop a promoted one, the same as the Forge card.

An agent whose workspace has paid or been claimed can send email from its own address, up to 20 an hour.

A self-registered agent that has topped up its workspace can lift the sandbox limits itself, and recover its key with the wallet that paid.
A store connection that looks up competitor offers by barcode now gets them. Before, every cycle came back with no competitor prices from that source.

Billing preferences save per workspace. Posting follows the saved email choice; numbering uses its starting floor, and instructions appear on invoices.

Pricing conversations now advertise their own payment resource, including signed vouchers and retries.

Read prices in their reported currency, with the decimal places that currency uses.

The public demo and keyless compute tool explain an out-of-range price instead of silently substituting 100000.

A past or invalid expiration date now keeps the key form open instead of creating a key without expiration.

Receipts, outcomes and usage lists refuse unsupported paging filters, and usage events honor the documented page and page-size form.
/api/mcp/rpc now lists eight tools instead of over 300. search_tools finds any other tool and call_tool runs it; add ?profile=full for the whole list.

Outcome corrections retain their previous values and reporting identity in your workspace audit history.

An agent that lifted its own sandbox can create helper agents and mint their keys with its own key, with no person involved.
Payout history returns the documented revenue, fee, net and period names, while keeping its existing ledger fields and currency units.

Priced answers now carry receipt.check_url. Send it with a price you quote, and the buyer or their agent can confirm it was computed on Last Price, with no account and no key.

Public price and verification demos retain their hourly budgets across app instances and explain when the budget cannot be checked.

Choose functions by name and assign relative weights without typing their IDs.

Get started now opens with two ways to hand setup to an agent: add the MCP address to your assistant, or create a key inside a message you paste into your own agent. The three manual steps follow.

Move through agent lists with Previous and Next, and filter by status before each page is selected.
Five open source packages on npm give an agent built with LangChain, the AI SDK or the OpenAI Agents SDK the Last Price tools in one install, plus a local MCP server you can run with npx.

Check tries a linked store or site without changing anything and says which part answers and which does not, before you sync.

Four screen recordings now show Last Price at work: the phone app pricing things from photos, and agents that price their own jobs and check each other's quotes. Watch or download them at last-price.ai/videos.
Our skills index now lists a skill for each job, from pricing and experiments to webhooks and billing, next to the last-price skill. Each one downloads with a checksum, and agents.json points to the full pack.
Three new MCP tools, set_experiment_status, delete_experiment and remove_experiment_conversions, let ChatGPT, Claude or any agent start, pause or complete an experiment, delete one, and take out wrong conversions.

Keep prices in collections like "Moving sale", see what your things are worth and price them again, list several at once, move a photo to the right thing, and, if you say yes, find things to sell in your recent photos.

Deleting, revoking, voiding or disconnecting now asks in a dialog that matches the app, says what stops working, and shows that it is working until the action is done.
Connect to /api/mcp/rpc?profile=lean and your client loads ten tools instead of over 300. search_tools finds any other tool by task and call_tool runs it.
update_alert_preferences now accepts invoice, payment, team, API key and low balance alerts, and list_notifications names every kind its feed returns.
Two new MCP tools: one ends the API key an agent calls with once its work is done, the other gives a webhook endpoint a new signing key. Tool descriptions now name the scopes they need.

When a price has several photos, the next one slides into view as the price appears, with a photo count and arrows. The "+N more" tile names what it holds and opens the full grid.

Before you change a function's price, replay the new price over the calls it already served and see what each customer would have paid. Nothing is saved or charged.
v0.8.0 is the first numbered release on last-price.ai. It brings collections and several photos at once to the mobile app, an Ask page for assistants that can only browse, delete confirmations, and a single index of every Last Price skill.

The Agents page includes revoked identities in All statuses and Revoked, while their access stays revoked.
A Shopify connection's shop_domain must now be the store's own your-store.myshopify.com address. Any other host is refused when the connection is created and on every sync.

A purchase check can now carry a card network agent payment intent, and a purchase under an intent that is no longer active is denied.

last-price.ai/downloads lists each assistant, coding agent and MCP client that works with Last Price, with the address or install command to copy for each.

An agent that signs its UCP quote or checkout requests with Web Bot Auth is now checked against its published keys and recorded as a verified buyer, with no token to fetch first.

In the mobile app, the photo you priced stays at the top of the result with the price tag on it, and the share sheet can save that card to your photos.

Add up to 12 photos and the app groups the ones that show the same thing. One thing gets one price with its photos to swipe through; several things get a grid with a price on each and the total.
Assistants that can open a page but not send a request, such as Perplexity or ChatGPT search, can now get a real answer from Last Price: open last-price.ai/ask with the item and the price, and the page says whether the price is too high, too low or in line, with the seller prices it is based on.
Delete and Revoke now name what they remove and ask before they act, and the pricing conversation accepts a lowercase currency such as usd.

One switch shortens every explanation on the website to its first line, or shows them all. Agents see everything by default, and the full text is always in the page.
A listing waiting for staff review now says so everywhere its seller looks, and buyers get one clear answer for a function they cannot reach yet.

Each listing you publish now shows its steps to live, why it isn't live yet, and what happened to it last.

The Pricing layer page shows the five steps of a sale, marks the one Last Price does, and links each step to the dashboard pages that handle it.
The read_quote_reply tool classifies a buyer's reply to a quote and returns confidence, option probabilities and any counter price.
If your workspace already connected its Stripe account to Last Price, you can link it as a store in one step. Last Price reads your products and sales and writes approved prices back, without a restricted key.

Choose French, Spanish, German, Portuguese, Japanese, Simplified Chinese, Korean or Arabic in Profile, Locale and display. Arabic reads right to left.

The date format, time zone and language on your profile now decide how the dashboard writes dates and times: invoices, payments, orders, disputes, the audit log, webhooks, team activity and more.

A candidate model that passes its evaluations can be promoted to price live quotes, and stopped again from the same card.

Learned pricing retrains candidate models from your quote outcomes and records what each would have charged next to the live price, without changing what buyers see.

Talk with someone about the business they want, and their page builds as they speak. Hand it over with a QR code, a claim link and a WhatsApp message.

Train a demand model from your workspace's quote outcomes, or upload an ONNX model, then choose which version a pricing function runs.

Price router, Pipelines, Price an item takes a description, a link, photos or a PDF and returns a price, a range and a draft listing or offer.

When an agent asks to spend more than its limit, you get a notification on your phone with Approve and Decline. The new Agents tab in the mobile app lists every request and your agents, and claims an agent from its claim link.

Settings, AI providers holds the Anthropic key for Last Price's own AI features and the connections for all nine inference providers your pricing functions call, the same ones as under Compute.

Stores whose search runs on Algolia can link the product index as a connector. Each synced product comes with its price and what shoppers did with it over the last 30 days: searches, clicks, add-to-carts, purchases and revenue.

Each API key shows whether it is active, expired or revoked, with the date, and the list can be filtered by status. Revoking names the key, updates the row straight away and confirms or explains a failure.

Settings has an Audit log page that lists who changed what and when: people in the dashboard, API keys and agents. Changes made while signed in to the dashboard are now recorded too.

Commerce checks connector credentials and pricing rules when you save them, and a price proposal expires after seven days or when a newer one replaces it.
A new MCP tool, describe_item_so_far, turns the words someone has said so far into a short sheet about the item, with pictures of that kind of thing, so ChatGPT or Claude can check it has the right item before pricing it.

In the mobile app, the item sheet suggests a name, details and pictures while you type or speak, and sharpens as you add words.

Partner workspaces lets an approved partner create a workspace for a business, run it, and hand ownership over with a claim link.

last-price.ai/price-check now prices one item from photos, a PDF, a link or a few words, with no account. Pick selling or buying and get a price, the range it sells in, its condition, and a listing or an offer to send.

A new MCP tool, price_from_capture, gives an agent the same pricing as the mobile app: send photos, a PDF, a link, a few words or a barcode and get a price, its range, and a listing or an offer message ready to send.

Settings, Price guardrails sets the limits every price in the workspace is held to, and previews the prices allowed for an example product before you save.

Two new MCP tools, list_price_checks and get_price_check, let ChatGPT, Claude or any agent read your price history: every price you got from a photo, link, PDF or description, in the app, through the API or in a chat.

Prices you check in the mobile app are saved to your account under History, and the same list is available from the API.

Tap the flag under any price in the mobile app to say the price looks wrong, the wrong thing was priced, or something did not work, and what you think it is worth. Every report reaches the Last Price team and is read by a person.
A new MCP tool, report_problem, lets an AI assistant pass on that a price is off, the item is wrong or something did not work, the same way the mobile app does, so the team can look at that exact answer.

Rosetta says which required fields are missing and why a record is invalid, and you can list or revoke the adapters it learned for each merchant.

Shops that take payment through their own Stripe account can link it as a store. Last Price reads your products and completed checkouts, and an approved price becomes the product's default price in Stripe.

Inviting a teammate now sends them an email with an accept link. The link opens a page that shows who invited them and to which workspace, and lets them sign in or create an account and join in one go.

Keys that create or change UCP checkout sessions need commerce:checkout. Quotes still need price:compute.

Checkout sessions carry expires_at and last 24 hours by default. Creating one again with the same idempotency key returns the same session.

Calls you have not paid for per call, by day pass or from your balance are not charged, and no invoice is sent for them. Usage now shows their cost as unbilled instead of billable, and their receipts say not charged.

GET /api/me now says which plan your workspace is on and what it allows: the daily compute limit, whether only built-in functions run, whether you can manage keys, which billing settings you can change, and how an agent sandbox moves to a full plan.

The workspace menu shows each workspace's role and short id, the choice holds across pages, devices and sign-ins, and Settings has its own picker. Owners are asked once to name a workspace still called My Workspace.

The quote-reply endpoint estimates whether a reply accepts, declines, questions or counters a quote.
The MCP server now opens with the one call that returns a price, lists the six tools that reach a price first (or alone, at ?profile=starter), and prices a declared cost with no key.
Agent registration responses include credential-persistence guidance so a restarted agent can reuse its workspace.
POST /api/compute/price reads the same flat fields the MCP compute_price tool takes, so an agent with only its cost gets a price on the first call and is told how the body was read. A request with nothing to price from is refused once, naming every way to fix it.
Work that cost nothing to make is no longer priced at 0. Cost-plus prices it from your band, and verify judges it against the floor only, so a seller and a buyer checking the same price get the same answer.

An agent connected to the MCP server with no key can now sign itself up with one tool call, register_agent, and the same MCP session uses the new key from then on: the call that needed a key works when retried, with no header to add and no client to reconfigure. An agent that already holds a saved key hands it to the session the same way, with use_api_key. A key a person keeps when claiming the agent's workspace now gets full access there, so it can change offer settings and other routing. Rolling out.
Two new MCP tools list the apps you connected by signing in and disconnect one, without opening the dashboard.

The frontier model combines a product's quote history with patterns learned from simulated markets to suggest a price and estimated acceptance.

An agent can describe a task and get a short, ranked list of offers it can call, each with its price, where that price sits in the market and why it is listed. Reels show real tasks done with Last Price as signed call transcripts an agent can read and run again.

Besides the full MCP server, Last Price can now serve five narrow ones: a price check, a quote verifier, an x402 price index, a negotiator and an agent-ready check. Each does one job with a few tools and has its own registry name, so an agent looking for that job finds it.

Buyer-aware pricing can now learn from the fields you send in metadata, nested objects and lists included. A feature contract names each field by its path in the request and says how it becomes a label; each quote keeps only those labels, never your raw metadata.
Add Last Price to Claude with one URL. The open tools work straight away, and the first tool that needs your account asks you to sign in.

Publish a selected set of pricing functions and products with a storefront page and agent discovery endpoints.

Attach merchant, amount, currency and expiry constraints to a purchase check or spend session. Network intent verification is not yet available.

Last Price now reads the public x402 discovery catalogs every day and turns what paid services list per call into a band for each kind of call: the low end, the middle and the high end, and how many services stand behind it. Price checks use it as a reference, check_purchase shows it next to the price, and anyone can read it. These are list prices only, never evidence of demand.

Last Price writes the Personal Agent Protocol file personal agents read to learn what you let them do, and checks it once you publish it on your own domain.

A buyer agent that pays for many small calls, such as x402 calls at a cent each, can open one session under your spend policy instead of checking every call. Each call draws its price from the session. When the run ends, whatever was not drawn goes back to your daily cap, and only what was drawn counts as spent.

The pricing analyst can prepare scheduled briefs, answer questions about recorded findings and draft changes for approval.
A 402 payment answer now carries how_to_pay: what to sign with a wallet, and the free ways in without one, so an agent that hits it knows its next step.
Every computed price now carries valid_until, so an agent knows how long it can quote or charge it. The window is 15 minutes unless the pricing function sets its own.

Each save of a spend policy now makes a new version, and every approved purchase remembers the version it was approved under. Right before paying, the agent confirms the purchase. If you tightened the rules in the meantime, it is checked again and refused when the new rules no longer allow it.
Eligible requests carrying a tester tag can ask for a Base Sepolia payment option.

An agent that sends an AgentID token with a UCP quote or checkout is recorded as a verified buyer, with the owner it acts for. UCP quotes now also show up in your usage.
Single and batch price responses round supported zero-decimal currencies, such as JPY and KRW, to whole currency units.

Behaviour tests send your email agent a set of test emails, from offers and refusals to pressure and attempts to get private details out of it, and show how it handled each one. Nothing is sent or saved, and runs use your own model key.
Inspect a public storefront URL for agent discovery signals and compare a margin scenario.

Fit models using supported buyer context and compare their proposed prices in shadow mode.
A chain can ask a language or vision model to annotate or adjust its running price within configured limits.

Read or update channel rates and include the channel on supported price and verification requests.
The cut advisor on Learned pricing estimates how an agent commission could affect your margin.
Experiments can now tell you when it is safe to stop, with a verdict that stays valid however often you check, and can shift traffic toward the arms most likely to win, with every change recorded.
MCP tool calls without a key share an hourly budget per address. Failed calls use it up six times faster than ones that work, and calls with a key are never counted.

Opt-in learned routing uses observed success, latency and rates to choose among eligible functions.

A pricing chain now raises the final price for its sales channel exactly once, at the end of the chain, so channel markups are applied consistently and never doubled.

The pricing page can now explain that our base rate is set by hand, that acting on a price changes what the next one learns from, and why the cheapest route is not always the one to pick.
A new table shows quality, speed and cost for each kind of request (short questions, long text, code, structured data, other languages) and each pricing function.

Check a quote's signature and expiry with the public verify_signed_quote tool.
Price requests and the MCP tools accept an optional buyer_agent label, so a logged quote names the agent a price was for.
Eligible experiments that name pricing functions can contribute head-to-head ratings to the leaderboard.

Learned prices now vary slightly from quote to quote, by up to 10% by default, so Last Price can learn what your buyers will pay. Never below cost, always inside your guardrails, and you can turn it off.

One request can now run several pricing functions in order, each stage's price feeding the next, with your guardrails applied once to the final price and each stage metered as one call.
A price response carries a signed quote, so a buyer can check the price came from Last Price and was not changed, without trusting whoever passed it on.

A preview page where 24 panels each recompute one simulated price every few seconds, every panel with a different pricing function. It is not open to everyone yet.

The connection form now gives each credential its own field, preselects the usual way to connect, prefills known values and highlights only what is left.

Browse older functions, public and owned listings, earnings and payout entries with Previous and Next. Catalogue search and tag filters cover the whole catalogue, and the publish form pages through your functions.

More diagrams now explain pricing, offers, routing, experiments and agent payments, with numbers worked out by the same rules the API runs.

Each scope in the Create new secret key dialog has a plain name, such as "Read billing" or "Manage webhooks", with its id underneath and a one-line description.
Each operation in the API reference is marked public, key or token, or signed-in person only.
POST /api/api-keys/rotate now needs {"confirm": true} in the body, because rotating ends the key for everyone who holds it.
Rosetta, price experiments, webhooks, marketplace listings, disputes and costs each have their own scopes, so a limited key or an agent can be given access to just that area.

The Notifications tab on your profile has a switch for each kind of alert, by email and in the app: billing, team, keys and low balance.
The OAuth metadata lists the scopes a token can carry, the narrower set a self-registered client gets, and the canonical issuer address.

Profile tabs give a clearer scrolling hint on your phone, and the photo button names the sign-in provider whose picture you can use.
A model function whose owner has not connected its provider no longer breaks cheapest or fastest routing for the workspace.
GET /api/openapi?view=scopes lists the scopes each operation needs, and admin-only keys no longer read usage or audit data.
A price sent with a unit cost and a target margin is no longer answered below that margin when a function other than cost-plus prices it.

With an authenticator set up on your account, sign-in asks for its six- digit code after your password or Google.

When a workspace has no AI key, Ask Last Price asks for one right under your request, saves it, and writes the agent straight away.

Billing records must match their customer, currency and amounts: a sent invoice keeps its amount, partial refunds track what is left, and a dispute cannot exceed its payment.

Each Commerce tab has its own address, proposals show their product and expiry, and a wrong competitor observation can be deleted.

Compute and router requests take up to 64 KB per body and 8 KB of context metadata. Larger requests are refused with 413 before anything runs or is charged.

Start, pause or complete an experiment, remove a wrong conversion, and limit an embed token to the experiments one page runs.

Credits, Create now saves a real credit bundle: pick a customer, name it, set the amount, currency and an optional expiry, and it appears in Credits with its balance.

Integrations now lists what this workspace can connect, with what is connected already: Shopify, Amazon and UCP stores, webhooks, your Anthropic key, and the MCP address to paste into Claude, ChatGPT or Cursor.

When an invoice has no address to go to, or email is not set up, the invoice page asks what to do instead of showing an error.
Changing billing mode needs billing:write, plans can no longer be changed through the workspace update route, and webhook URLs must be public HTTPS addresses.
The last-price Agent Skill teaches an agent to price something, check a price against the market, and check a purchase against its owner's spend policy before paying. Load it from our skills index.
When an invoice nets a credit, discount or deduction against its charges, the payment agent stops and asks a person before paying it.

last-price.ai/price-check now checks a live price: say what you sell, what you charge today and who buys it, and get the price to charge, how sure it is and why, and a second price worth testing. No account needed.

Buttons a role cannot use are greyed out with a line saying which roles can, new API keys only offer the permissions your role holds, and the roles and what each may do are listed in the docs and the API.
Webhook signing secrets have their own rotate route, and a token stops working when the key it came from is revoked or rotated.
A UCP quote with a bad quantity, price or currency is refused with the field and line named, and a body that is not JSON answers invalid_json.
Email negotiation agents and the AI-assisted agent setup flow now use a current AI model after the one they relied on was retired.

Every Last Price MCP tool now carries a title and hints that tell your host whether a call only reads, changes or deletes something, or reaches outside Last Price, so it can ask you before the calls that matter.
Play the seller in a demo negotiation, or ask questions about your workspace's pricing findings, from Agents or through the API.

Signing in with AgentID explains before redirect that the agent identity and its owner's name and verified email are requested.

The function list, public catalog, marketplace listings and earnings document total matching results in pagination.total.

Check an agent's capabilities, usage records, model-call costs and remaining day-pass calls.

Compute batches, configure routing and guardrails, and manage price experiments from an MCP client.

Read and manage credits, invoices and payment records from an MCP client.
Every refusal from POST /api/agents/claim now carries a code, a server failure carries a reference for support, and the claim page shows both and lets you retry instead of saying the workspace cannot be claimed.

Inspect catalog items and proposals, manage pricing policies, and run store pricing workflows from an MCP client.

Share price observations, query the exchange and inspect contribution history and token balances.

Manage pricing functions, inspect their health and record operating costs without leaving an MCP client.
The payment guide explains wallet setup and how to respond to a payment-required API response.

Maintain your listings, inspect recorded earnings and work through dispute records from an MCP client.

Read and update customer records, contacts, orders and order lines from an MCP client.

The public list_pricing_pipelines tool describes reference pipeline designs and their stages.
The jale-psychological function no longer turns a price under $1 into $0.99. A sub-cent price stays at one cent, and cheap prices get an ending at their own scale.
The agent discovery documents include Rosetta ingestion and schema-translation endpoints with their access requirements.

An agent or API key that queued a held mapping cannot approve or reject it. A person, or a different agent or key, has to.

Use Rosetta mapping tools, inspect experiment recommendations and run profiling on a connected AITune server.
A tester tag attributes supported pay-per-call requests to test traffic in Live traffic.

Discover a UCP profile, price a cart and manage checkout sessions through MCP; payment completion is not yet available.

Read and update workspace settings and inspect provider connections from an MCP client.
Claiming a workspace an agent registered for itself failed with a server error and changed nothing. The claim now completes.
API responses distinguish missing credentials from an unsupported credential type and reject ambiguous function fields.

Company settings now has the company logo uploader, next to the company details it belongs with. Billing settings keeps it too, and both save the same logo.

A demo price request with no current price now opens with the field to add and a body that works, and every MCP tool that needs a key says how to get one in a single call.

Seller agents can configure offers, and buyer agents can negotiate through public tools using a buyer token.
Candidate providers, applied limits, and any routing failures are now recorded for each price and batch call so you can audit and tune your routing policy.

Discovery and MCP descriptions identify capabilities that require a claimed workspace.

A buyer agent whose payment timed out can now report the outcome unknown. The amount stays held against the daily cap and can't be released until someone checks whether the money moved, so a retry can't pay twice.

List members, manage roles and send or revoke invitations through MCP with a dedicated administrative API key.

An agent can now buy a day pass, top up its balance, pay for a single priced call and check its wallet balance from its MCP session, signing with its own wallet.

An Agent2Agent agent card at /.well-known/agent.json lists what an agent can ask Last Price to do, and points to the calls that compute, verify and record a price.

Choose "Once a day" for any email alert to get one summary at 8:00 in your time zone instead of an email each time. Alerts about an approval already decided, a dispute already closed or an endpoint that recovered are left out of retries and summaries.

Your own agent can now list, read, approve and reject held actions, and read the audit log, through the MCP server, the tool packages and the API. It can never decide a request it made itself.
Each priced item of a batch compute call to a function you list now adds to your pending earnings as it happens, the same as a single call.

A spend policy caps what your buyer agents pay: the most per purchase, a daily cap, a threshold above which a person approves, and which sellers. Any buyer agent checks a purchase before paying and gets allow, deny or ask.
Price requests accept an optional buyer type, agent or person, so each logged quote records who the price was for. Identifying-looking segment and geo values are now dropped from the logged quote.
Every feature now has its own RSS and JSON feed, so you or your agent can follow just billing, webhooks or MCP without sorting through the rest.
Agents can now ask what shipped, by feature and since a date, through a new get_changelog tool, with no API key needed.

The public leaderboard combines eligible usage measures with reported outcomes and supports 7-day, 30-day, 90-day and all-time views.

Owners and admins now get an email when a call is held for approval, a dispute opens, or a webhook endpoint keeps failing, and choose which ones in their profile. Agents get the same alerts through the notifications feed, MCP, webhooks and their own inbox.

An experiment can now test up to ten prices at once instead of two, and its results compare every arm with your control, raising the bar as you add arms so more arms do not mean more false winners.

You can now create your API key, check for your first call and activate your pricing function without leaving Get started, and any page a step does open leads straight back.

Learned pricing no longer needs you to report every quote. Quotes nobody reported on now count too, read from the orders that followed them, so an estimate is ready with far fewer reports and is less skewed by which outcomes buyers bother to report.

Learned pricing uses reported quote outcomes to estimate demand sensitivity, with previews and approval controls.

A function now passes an automated review before other workspaces can route to it, and the endpoint of every external function is checked each hour, so you see why a listing stayed private and when an endpoint stops answering.

Create and maintain webhook endpoints, send a signed test event and inspect delivery attempts from an MCP client.

A new built-in function, the optimal stopping rule, tells you whether one more round of a negotiation is worth what it costs, from the offers so far, and always says whose economics forced the stop.

A small blue dot in the sidebar marks a page when a release note about it shipped since you last opened it. Opening the page clears the dot.

Open a product to offers and any buyer, or the agent shopping for them, can name a price with no account. Each offer is answered with accept, counter or reject, with the price and the reason, and never below your floor.

Every code block and command snippet across the docs, developer pages, and dashboard now has a Copy button so you can grab any snippet without selecting text by hand.
Outcome pricing opens a reporting window for eligible balance-funded compute, router and batch calls.

Pricing analysis summarizes recorded outcomes, learning readiness, guardrail effects and pending approvals.

Pricing output applies supported currency precision, floor and ceiling constraints, and bounded charm-price adjustments.

Seven pricing functions of about ten lines each, from cost plus to one price for agents and people, with a step by step guide to run one on your own endpoint and register it. Every example on the page is checked on each change.

Product categories groups your products into a short category tree, suggests a category from each product's name for you to confirm, and shows how many outcomes each category has toward the 30 an estimate needs.

A new Releases page lists every deploy to production, newest first, with the date and the changelog notes it shipped.
On the local MCP server and in the tools packages, report_outcome can leave out usage_event_id and report the last price compute_price returned on that connection, once.
A matching idempotency key can replay a completed request or resume the failed items of a partial batch.

Connect a Shopify store with the client ID and secret of an app from Shopify's Dev Dashboard, and Last Price keeps its access token fresh for you. Price changes are written to Shopify again on its current API.

Connect a Shopify store's orders and every sale becomes demand data for learned prices, with no one reporting outcomes. Orders arrive by webhook as they happen, and a pull backfills the last 60 days.
Testing a pricing function now works while it is still a draft, so you can check what it prices before it takes live traffic.
The verification response identifies when its reference price depends on the price being evaluated.

Three new webhook events tell your own tools when a person has something to act on: an agent call waiting for approval, a dispute opened, and a price change proposed. Route them to a chat channel, a pager or a ticket queue.
Competitor observations and checkout idempotency records are scoped to the workspace making the request.

The agent inbox now falls back to locally stored messages when the external mail service cannot be reached, so mail remains visible even during an outage.

The pricing step of agent setup now asks what each fee costs: an amount, a currency and how often it is billed. It used to record only that a fee was switched on, and the agent's page now shows the fees you set.

Fetch company info in Company settings now fills in your company's name, description and logo from your homepage. Before, it only said that company enrichment was not configured.

Two pricing functions that were listed but could not be called now work: a significance test that says whether a price variant has won, and a traffic allocator that decides how to split the next visitors.

A cost multiplier you set on a function is now kept, and built-in functions bill at their listed multipliers, from 1x to 5x. Until now every call was metered at 1x, whatever the function said.

Connecting an inference provider on the Compute page now saves the key for your workspace, encrypted, after the provider confirms it works. Before, the card said Connected but the key was thrown away.

An LLM prompt or ML model pricing function can now run on an inference provider your workspace connected, with your own model and pricing instructions. Before, these functions quietly used the basic rule-based formula.

Model Profiling now runs on the AITune server your workspace connects on the Compute page. Before, it could only use a server set up by Last Price, which did not exist, so the page always said AITune was not connected.

The Notifications panel in the sidebar now lists approval requests, failed webhook deliveries, email to your agents, disputes and proposed price changes for the selected workspace, and the Monitor tab shows how many are unread.

Confirmations and error messages now appear on screen after you save, delete or send something in the dashboard. Before, they were raised but never shown, so a save or a failure gave no feedback.

Every release note is now tagged with the parts of the product it changed, such as Webhooks or Credits and billing. Pick a feature to see only its notes, or tap a tag on any note.

Request a receipt for a priced call or a statement for a period, with recorded costs and the signal values you configure.

Settings, Sales playbook now keeps your ideal customer profile, value propositions, pricing guardrails and commercial terms for the workspace. They used to disappear when you left the page.
Rate limits on dashboard sessions now track individual people rather than shared network addresses or workspaces, so teammates on the same network no longer affect each other's limits.

The built-in Usage table, Invoice table, Payments table, Container and Pricing calculator blocks were placeholders. They now render real content: the tables read your own data through a small server route you copy into your app and protect with your own sign-in, and the calculator works out graduated tier pricing.

Settings, Tax now keeps your company address, US nexus states, EU VAT (OSS) number and other VAT or GST registrations. They used to disappear when you left the page.

Inspect your workspace's billing, compute, experiment and price-contribution records, with clear empty and failed-load states.

Every webhook now carries its signature in x-lastprice-signature and its timestamp in x-lastprice-timestamp. The previous signature and timestamp headers are still sent with the same values.
Status badges, code examples, and small labels are easier to read in both light and dark mode, the show-password button works with screen readers, and the dashboard now respects your system's reduce-motion preference.

The reference covers webhook delivery, routing, agents, billing records, usage and discovery, with links from the integration guide.

A new Approvals screen lists the agent calls waiting for a person's sign off, with Approve and Reject buttons, and the approval link an API call returns now opens it.
Tell Last Price who pays for model inference. When your customer brings their own AI subscription or key, the model cost drops out of the price, so you can offer a cheaper plan and keep your margin.

The default optimizer uses supplied cost and elasticity to optimize modeled profit within the pricing constraints.

The tabs on a customer's page now show one section at a time, and Payments, Credit balances and Costs list that customer's records.

The documentation pages are readable without signing in, and AI agents are directed to llms.txt for the current access rules.
New or updated endpoint credentials are encrypted before storage and omitted from function API responses.

The Get started page now shows three real first steps (create an API key, compute your first price, publish a pricing function) and ticks each one off once your workspace has done it.
The JSON and RSS release-note feeds now carry the 50 newest notes, so agent fetch tools can read them, and signing in to list a function says why an account is needed.

Save a maximum change, a minimum margin, a never below cost rule and the optimizer's search range once, and every price your workspace is given respects them, whichever pricing function computes it.
The privacy policy now explains that last-price.ai keeps daily counts of API and MCP access. These counts never include full API keys, tokens, or IP addresses, and are deleted after 180 days.
The privacy policy now explains the product analytics and session recordings we may use, and that typed text, keys and secrets are masked.
Opening an expired or already used password reset link now shows a clear message and a button to send a new link, instead of a form that fails with a session error.
A saved default routing policy could be skipped for some pricing requests; it now applies to every request, wherever it is served.
The marketplace price history source now reads the regional store you configure and reports its prices in that store's currency, so catalogs priced in euros, pounds, yen and other currencies get competitor matches.
The credential lookup now reports the actor kind behind every credential, so an agent's own API key answers agent instead of null.
The public function catalog and the public marketplace listings can now be read with no API key, so an agent can see what the network offers before it signs up.
The public pipeline run operation, which has never computed a price and always answers 501, is now marked deprecated and says so in its response headers.
The support address now opens a real page with the support email, links to the docs and agent discovery files, and fixes for the most common errors.
Usage-signal requests take eventType and optional agent, customer and metadata fields directly in the request body.
Workspace roles determine who can manage keys, settings, billing records and team ownership.
Exchanging an agent key for a token does not grant workspace administration or access to other agents.
A workspace with balance billing on now pays for batch pricing from its prepaid balance, one call per item at the prepaid price, and a batch the balance cannot cover in full is refused with nothing charged.
You can now change the events an existing webhook endpoint receives from the dashboard, including the product updates event, without recreating the endpoint or its signing secret.
Agents can send a competitor offer and business limits to get a metered price suggestion or a clear request for missing inputs.
Unsubscribing from one of our marketing emails now turns off the Marketing emails switch in your profile, and every change to that choice is kept in a history you can see.
A tool call on the MCP endpoint that runs past 30 seconds is now stopped and answered with a JSON-RPC timeout error that says to retry, instead of the connection ending with no answer.
What shipped is now also published as a newsletter every other week, in an edition for people using Last Price and a more technical one for agent builders, with a public archive and an RSS feed.
Usage records identify calls paid through pay-per-call payments, a day pass or prepaid balance.
A self-registered agent workspace can buy a day pass with one wallet payment, adding extra compute calls for 24 hours that are used once its daily limit is reached.
Owners and admins can give an agent a key with the Manage the team permission, so it can invite people, change roles and remove members for them, within strict limits and with every change listed on the Team page.
A self-registered agent that reaches its daily compute limit can pay for the next call with a wallet payment and have it run straight away in its own workspace, with no claim and no person.
The agent manifest, the MCP manifest, llms.txt and the self-registration response now say where the changelog feeds are, how to keep only the entries written for agents, and when to check them.
Calls made with an API key to the pricing, function list and credential routes now carry up to three notices about changelog entries for agents the key has not been shown yet, and the API keys page shows when each key was last used.
New store connections can import competitor offers for pricing proposals while preserving price limits and approval rules.
Compute responses can include a usage receipt, remaining limits, permitted next actions and a routing-cost comparison.
The Legal page and the Terms of Use now explain how to report content on Last Price that you believe infringes your copyright.
A retiring API operation now says so on every response with standard Deprecation, Sunset and Link headers, and a new platform.changelog webhook event tells your endpoint when a changelog entry for agents is published.
API errors can include field issues, an example request, authentication guidance or retry timing.
A Marketing emails switch in profile settings takes you off our marketing list, and our emails can now carry the sender's postal address.
The hosted MCP endpoint now implements the standard Streamable HTTP transport, so a client can hold a session and open a stream that tells it what changed, while plain JSON-RPC POST keeps working exactly as before.
A workspace can top up a prepaid balance in USDC with one wallet payment and have compute calls draw it down at a lower price than paying per call, with a bonus on larger top-ups.
Pricing conversations ask clear questions, retain your answers and explain assumptions before you run a computation.
The Terms of Use now say you must be at least 18 to use Last Price, and the sign-up and sign-in pages link both the Terms and the Privacy Policy.
Keys can now be limited to billing or commerce work, those routes check the scope, and every commerce operation is in the API reference.
GET /api/usage/llm/events lists individual AI-backed calls, and PATCH /api/usage/llm/events/{id}/outcome records whether one was accepted, alongside a quality score.
The AI tab on the Usage page now charts tokens per day across metered AI operations and shows what they cost in euro next to the dollar figure. AgentMail calls are not included yet.
Sandbox agents can rotate their own keys and read current access limits from discovery responses.
A workspace an agent creates for itself is now on its own Agent Starter plan, with 25 compute calls a day until a person claims it.
A claimed agent workspace now sits under the workspace you pick, keeps everything in it, and a trusted agent can claim for you with a new permission.
When you claim a workspace an agent created, the key the agent holds is now revoked unless you choose to keep it, and the claim page says plainly what keeping it means.
Use a Base wallet to sign in, link it to an account, and review its recorded pay-per-call payments.
The no-key pricing demo is now listed in llms.txt, agents.json and the docs, the homepage example shows the demo's real answer, and every advertised discovery link resolves.
An agent can now register itself and receive a sandbox workspace and a restricted API key immediately, plus a claim link for a person.
Every 401 response now carries a code, message and retryable flag, so agents can handle auth failures the same way everywhere.
The public marketplace and the Elo Index now list eight of Last Price's own built-in pricing functions, marked as built-in.
Live traffic now names the agent or client behind every pricing request and separates your own agents, your testers and everyone else.
The Browse tab in the dashboard marketplace lists the functions actually published on the network instead of sample entries.
POST /api/mcp/rpc serves the Last Price MCP tools over HTTP, so agents that configure themselves from /.well-known/mcp.json can connect.
OAuth client credentials frameworks can now find the authorization server metadata and register a client with no human.
Where enabled, a call to POST /api/compute/price with no credential answers 402 with x402 payment requirements, and a signed USDC payment buys that one call.
An external pricing function that answers with no usable price or confidence now counts as a failed attempt and falls through to the fallback chain, instead of reporting your own price back as a computed answer.
Every computed price now explains how it was produced, and a new live traffic view shows your requests as they happen.
You can now record whether a computed price was accepted or rejected, plus an optional quality score, against the usage event that produced it.
Agent inboxes can send new messages and reply within the original email thread.
Malformed experiment responses now report unavailable instead of generating prices from fallback assumptions.

The mobile client accepts supported shared photos, screenshots and links and retains them while restoring your session.
Unavailable pipeline execution returns an explicit error instead of a simulated pricing result.
General workspace settings no longer return or replace stored integration credentials.
Selecting a function by ID or name does not grant access to another workspace's private function.
Without a key, the MCP server now lists its tools and runs the demo pricing tools instead of refusing every call.
Pricing requests can omit a product ID when the supplied context gives a supported function enough information.
Scoped credentials need the compute permission for single-price requests, and successful router calls contribute to recorded usage.
Manage contacts for each customer and select one as an order's billing contact.
Stored routing strategies and their constraints affect requests without an explicit routing choice.
The AI usage tab shows recorded calls, tokens and model costs for a selected period.
New listings that omit a commission rate use the 30% platform default; existing listings retain their configured rate.
The API reference describes request fields, response envelopes and operation-specific types for billing and customer records.
Describe an agent and receive a generated draft with a name, description and signals.
Draft and cancelled orders can now be deleted from the orders list or through the API, and their line items go with them. An order that has started billing cannot be deleted outright: cancel it first.
Connect the pricing snippet to your storefront with an embed token and registered browser origins.
An MCP server gives agents a compute_price tool that returns the same price as the REST API.
Clicking an order in the list opens the order instead of a missing page, and the order now shows its line items.
Experiments that could never run are rejected when you create them, and the traffic split you configure is now applied.
Generate model estimates of the human labor a task could require in selected countries.
GET /api/me returns the workspace ID, authentication method and scopes associated with your credential.
A new "Load sample data" button on the Commerce dashboard sets up a demo store, competitor prices, and a pricing policy, then runs a cycle so you can see and approve a real price proposal without connecting a store.
The pricing models page and API list the model records saved for your workspace.
The signals page and API show usage events recorded for your workspace.
Webhook endpoints you create are now saved to your account, survive page reloads, and support a signed test ping with a per-delivery log.
Supported dashboard API routes accept the browser session and validate the selected workspace.
Use the capability endpoint and API reference to select a function and prepare a pricing request.
Newly saved connector credentials use authenticated encryption before database storage.
We rebuilt the account flow from scratch. Sign in and sign up have their own pages, sessions refresh automatically as you browse, and Google sign-in lands you in the dashboard in one click.
The legacy x-user-id header no longer authenticates API requests.
Pull connected catalogs and observations, prepare price proposals, and optionally execute approved changes.
Privacy Policy and Terms of Use have been rewritten in plain language. The old /tos URL now permanently redirects to /terms, and a new /legal hub links to both.
A browser-side tool at /product/webhooks/verify that confirms a webhook payload was actually sent by us. Paste the signature header and body, get a green check or a precise reason it failed.
Manage workspace membership and assign roles for shared work.
The function catalog includes pricing, experiment analysis and schema translation tools.
One call to POST /api/rosetta/ingest takes a merchant payload, proposes a canonical mapping, validates it against the catalog schemas, and stages the result for review.
Dashboard layouts adapt to smaller screens, with contained tables and scrollable dialogs.
Translate merchant records into a target contract and inspect the proposed mapping and validation results.
Workspace provider API credentials are encrypted when saved in production.