Add packaging quoting to your AI agent: MCP and the headless API

What your agent gets

The goal is narrow and useful: your agent takes a label artwork file a user already has and returns a real roll-label quote link instead of a vague guess. Under the hood, PackOS Quick Quote reads the file for attributes such as dimensions, die shape and colors, shows them for the user to review and confirm, and prices the job across the available quantities. Your agent never has to model materials or press setup; it hands off a file and gets a link. Quick Quote prices custom roll labels only — flexible packaging is coming soon. For the pipeline behind that, see how instant packaging quotes work.

There is one integration surface today: the headless upload flow over HTTP. If your agent speaks the Model Context Protocol, you can wrap those calls as a tool in your own MCP server; a hosted PackOS MCP server is planned. Either way the calls authenticate with the same partner key, and qualified quotes are credited to that key under the partner program.

Get a partner key

Partner keys are issued by PackOS on request during early access; there is no self-serve registration endpoint yet. Request one on the partner page and name the origin your agent or backend will call from — the key is bound to registered origins, and a request from any other origin is refused. Signing an upload also needs a live key.

Keep the key where your agent can read it. It is public by design — it identifies the origin of a quote so attribution works, and it grants no access to uploads or account data. A discovery manifest at /.well-known/packos-partner.json is planned (see the manifest design) but is not published yet.

The MCP path (planned)

A PackOS MCP server does not exist yet, and no package for it is published — do not install or reference one. If your agent runtime supports the Model Context Protocol, the practical option today is to wrap the HTTP calls in the next section as a tool in your own MCP server. When a hosted PackOS server ships, the intent is that an agent discovers a quoting tool by name, with the partner key kept in the server's environment rather than the model context.

The headless path: sign, PUT, commit, hand off

For a backend service or a script, call the API directly. The flow is a few steps with no UI: ask PackOS to sign an upload, PUT the bytes to the returned storage URL, commit the upload so it is attributed to your key, then hand off the returned quote link to the user. This is the same flow the embed performs; you are just doing it server-side. Here it is in JavaScript (early access: keys are issued on request, the request's Origin must match an origin registered for the key, and signing needs a live key):

const KEY = process.env.PACKOS_PARTNER_KEY;          // pk_live_… issued by PackOS on request
const API = "https://packos.ai/api/embed";
const ORIGIN = "https://your-registered-origin.example";  // must be registered for the key
const headers = { "Content-Type": "application/json", "Origin": ORIGIN };

// 1. sign — ask for a one-time upload URL
const sign = await fetch(`${API}/sign`, {
  method: "POST",
  headers,
  body: JSON.stringify({ key: KEY, filename: "label.pdf", size: fileBytes.length, contentType: "application/pdf" })
}).then(r => r.json());

// 2. PUT — send the file bytes straight to storage, with the headers the signer returned
await fetch(sign.uploadUrl, {
  method: "PUT",
  headers: { "Content-Type": "application/pdf", ...sign.uploadHeaders },
  body: fileBytes            // a Buffer / Blob of the label artwork
});

// 3. commit — bind the upload to your key and get the hand-off link
const done = await fetch(`${API}/commit`, {
  method: "POST",
  headers,
  body: JSON.stringify({ key: KEY, objectKey: sign.objectKey })
}).then(r => r.json());

// 4. hand off — give the user the quote link (opens Quick Quote on their file)
console.log(done.quoteUrl);

The upload URL is short-lived (ten minutes) and create-only. Your key goes in the request body (or an X-Packos-Key header) on the sign and commit calls; the raw PUT goes to storage and needs no key. After the commit, the user opens the returned link and Quick Quote takes over: it detects the label attributes for review and prices the job once the specification is confirmed.

A worked example: label file in, quote link out

A user sends your agent a label artwork PDF and asks for a quote. Your agent does not have to become a label estimator: it runs the calls above with the file and returns the quote link to the user, who reviews the detected attributes, confirms the specification and reads the quantities, assumptions, tooling and delivery terms in Quick Quote. This flow takes a file; it does not accept a written spec on its own, and only custom roll labels are priced (other formats are not quoted, and flexible packaging is coming soon). If you would rather your agent build a page a user lands on, see building a packaging quote page with an agent.

The trust boundary: what stays on PackOS

The security story is deliberately simple: the embed and your agent are thin clients. They collect the file and carry a public partner key, and that is all. The upload target, the AI detection models, the cost model, and the attribution ledger live on PackOS. Nothing sensitive sits in your agent, in the browser, or in the model transcript, which is why the partner key is safe to ship in client code.

That boundary is what lets an agent run end to end once it holds a key: embed the quote flow and, in the partner program, earn on the qualified quotes it drives. During early access keys are issued on request. When there are earnings to withdraw, they pay out to a connected account you link at cash-out — fiat or a USDC wallet, your choice. How that works end to end is covered in how an AI agent earns commission with PackOS.

What is live, and what is early access

To be straight about status: Quick Quote is live for custom roll labels, and you can run a real label file through it today; flexible packaging is coming soon and other formats are not offered. The partner program is in early access: the partner-keyed upload flow above exists and keys are issued on request, while self-registration, the MCP server, the discovery manifest and commission attribution reporting are planned or still being rolled out. The developer docs currently document only the Open Calc API, so treat what is written here as the authority for the upload flow. Payouts are not live yet, so there are no earnings to promise; when they open, the commission model (paid on real, qualified quotes — quality, not bot traffic — plus rev-share on a resulting order) and the exact rates are published to partners at signup.

If you want to start, request a partner key, wire the upload calls, and run a label file through them. Join the early partner list so your key is attributed the moment the program opens.