Why CPG Scheduler is headless and agentic

Production planning is decision-work. It's checking which SKUs are trending below par, pulling the week's run schedule, summarizing variance after a shift, answering "can we fit this rush order in before Friday?" — a steady, all-day stream of questions asked against live operational data. Look closely and almost none of it actually requires a human sitting in front of a screen. The screen is incidental. The answers are the point. So we built CPG Scheduler to be operable without one: headless and agentic.

The case for headless

A graphical interface is the right tool when a human is making a judgment call — weighing a tricky sequence, deciding whether to split a run, signing off on an exception. It is the wrong tool for the dozens of small, routine reads that fill an operations day. "Is anything below par?" should not require opening an app, navigating to a view, and scanning a table — least of all at 6 a.m. before the floor spins up.

Headless means the application's capabilities are available as an interface a program can call, not only as a screen a person can click. That distinction unlocks the one thing screens fundamentally can't do: continuous, on-demand operation. A monitor that checks coverage every hour and pings you only when something crosses a line. An assistant that answers planning questions in plain language while you're walking the floor. A morning brief that's already written, with the day's risks ranked, before you sit down. The work stops waiting for someone to log in and go looking for it.

Why agentic, and why now

For most of software's history, "headless" was a promise that only paid off if you had a developer. Someone had to build an integration against an API, then maintain it, then babysit it every time something changed. The capability was theoretically available and practically out of reach for the people who'd actually benefit.

What changed is two things at once. AI agents got genuinely capable of using tools to accomplish multi-step work — and the industry converged on a standard for handing those tools over: the Model Context Protocol (MCP), introduced by Anthropic in late 2024 and since adopted across the major AI providers.

It's worth understanding what MCP actually solves, because it's the reason this is suddenly practical. Before it, connecting M agents to N tools meant building M×N bespoke integrations — every agent against every system, each one hand-written and separately maintained. MCP collapses that to a single standard interface: a tool provider exposes its capabilities once, in a defined shape, and any compliant agent can discover and call them without custom glue. The agent asks the server "what can you do?", gets back a typed list of tools, and calls them as needed. That's the whole trick — and it's what turns "we have an API" into "point your assistant at it and go."

CPG Scheduler runs an MCP server that offers your production data as exactly that kind of toolset. You don't write an integration. You point an agent at it, give it a token, and it can answer "which SKUs are below par with no run scheduled this week?" against your live data — not a stale export, not a screenshot, the actual current plan.

Read the plan — and, now, act on it

The toolset comes in two halves. The read tools let an agent observe: list production runs, read the calendar, pull SKUs and lines, surface alerts, generate a performance report. That alone covers most of an operations day — the status checks, the briefs, the "what's exposed right now?" questions.

The write tools let it act: schedule a run, update or split one, acknowledge a flagged risk, create or update a SKU, adjust your production lines. This is the part that closes the loop. An agent that can only read hands you a list; an agent that can read and write can take the routine decision all the way to done and simply tell you what it did. The morning monitor that spots a stockout risk can now schedule the run to cover it — within the limits you set — instead of waiting for you to open the app and do it by hand.

A few workflows that become possible once the loop is closed:

• A morning brief that schedules itself. Every day before standup: pull alerts and coverage, rank the exposed SKUs, schedule the runs that are clearly due, and leave you a summary of what it did and what it left for your judgment.
• A coverage monitor that acts. Hourly: check below-par coverage; for any A-item below its reorder point with open capacity on the right line, schedule the run and note it. You get a message, not a fire.
• A plain-language planning partner. "Can we fit a 5,000-unit rush of SKU-204 before Friday without blowing the changeover budget?" — answered against the live plan, with the run scheduled on your say-so.

Yours, scoped, and revocable — emphatically not a public API

This is the part we care about most, and the part we designed first. Agent access in CPG Scheduler is first-party: it is your agent, acting as you, on your organization's data. It is not a public API, not a data marketplace, not a third-party app store, and not an external sign-up. Nobody you didn't authorize gets near your plan.

The mechanism is a scoped agent token you mint from your profile. You choose exactly what it may touch — and, just as importantly, what it may do. Grant a token only reports:read and it can pull a variance report and nothing else. Grant runs:read and it can see the schedule but never change it. Add runs:write and it can schedule and adjust runs — but only runs, and only as you. Read and write are separate scopes, so "let an agent watch" and "let an agent act" are decisions you make independently, per token.

The guarantees underneath are deliberate. The token is shown to you exactly once and stored only as a one-way hash, so even we can't reproduce it; it carries an expiry; and it's revocable the instant you want it gone. Every call runs with exactly your permissions on your organization's data — an agent can never do anything you couldn't do yourself in the app, and never one scope more than you granted. It's the difference between handing an assistant a key to a single room and handing them the whole building. Start a token read-only, watch what your agent does, and widen its scope only when you're ready — the design lets "let an agent help" stay deliberate, never "let an agent loose."

What this is really about

Headless-and-agentic isn't a feature we bolted on; it's a stance about where an operator's finite attention should go. The routine reads, the status checks, the end-of-shift summaries, and now the obvious, in-the-rules scheduling decisions — the work that's important but not hard — get handled continuously by something that never gets tired, never gets distracted, and never forgets to look. The judgment calls — the genuinely hard decisions that deserve a person — get a person who isn't burned out from grinding through the busywork by hand.

The full setup reference — connecting a client, the endpoint, and the complete tool and scope list for both reads and writes — lives on the for agents page. If you're ready now, mint a token in your profile and point your agent at it.