One API and one MCP over your whole ops.
One REST API and one MCP server over support, incidents, monitoring, and your status page — one product to build on, not four bolted together. Because underneath, they're the same data model.
Built for small teams who'd rather automate the busywork than hire someone to do it.
No "Get API keys" button yet — we're pre-launch. The waitlist is how you get in early.
Four tools have four APIs. We have one.
Stitch a status page, an incident tool, an uptime monitor, and a helpdesk together and you inherit four APIs, four auth schemes, and four sets of webhooks to keep in sync. Every integration you build is glue between tools that don't know about each other.
StayUpfront is one product over one data model. Support tickets, incidents, monitoring, and the status page are views of the same state — so it's one REST API and one auth model over all of it, launching with us. The status page updating itself when a monitor fails isn't an integration you build. It's the default, because the status page is a view of the incident the monitor raised.
Four keys, four auth schemes, four sets of webhooks — and the glue between them is yours to build and keep in sync.
One data model underneath, so one surface over all of it. The integrations between them aren't yours to build — they're the default.
Drive it from your own tooling.
Raise an incident from a check your own systems run. Post an update programmatically when you've found the cause. Move a component's status, acknowledge from a script, link a ticket to the incident it belongs to.
And the thing most teams build first — "POST from my monitor to my status page" — you don't have to. The status page is already a view of the incident. The best automation is the one you never have to write.
Bring your own agent — scoped to exactly the right reach.
We're not going to lock you into ours. We're launching with an MCP server and a REST API, so if you already work with an agent — Claude, or anything else — it can reach into your ops and act: raise an incident, post an update, triage a ticket, check what's up, from your editor, your terminal, or wherever it already lives. Your model, your credits, your side. You don't have to use an agent at all — the surface is just there if you want it.
And when you do connect one, MCP access comes at three levels — individual, system, and customer — so an agent gets exactly the reach it should have and no more.
A team member points their own agent at StayUpfront to help with their role — scoped to exactly what that person can already see and do, never the whole org.
An agent that acts for the org — automation across your support, incidents, monitoring, and status.
Your customers can talk to it too, over MCP — scoped to a single customer's own view, with exactly that customer's reach and no more.
Sue, the AI inside StayUpfront, is ours — here for the team that wants AI built in. The MCP server and API are how your agent drives StayUpfront, here for the team that already has one. Not either/or. Either way, you're not trapped.
Meet Sue — the AI built inYour API reference, where your customers already are.
Got your own API? Publish its reference straight from StayUpfront — paste a spec, upload a file, point at a URL, or build it up operation by operation. It renders as a clean, navigable reference, with a "Try it" console so your customers can call a real endpoint from the page. Export to JSON, YAML, or a Postman collection. Write guides alongside the reference, ship version diffs and a changelog, and expose an /llms.txt so agents can read your API too.
And it lives in the same place as your status page and your support — not in a separate docs tool with a separate bill. One login. One surface your customers trust.
- GET /orders
- POST /orders
- GET /orders/{id}
- DELETE /orders/{id}
Create an order. Returns the created order with its assigned id.
Illustrative — your own API reference, rendered and hosted in StayUpfront.
Dev-grade depth, without the dev-portal bill.
Hosting your API reference shouldn't cost what a dedicated docs platform charges. Automating your ops shouldn't cost per developer who touches the API. StayUpfront is billed per organisation, not per seat — add every engineer on your team, give each their own agent, and the bill doesn't move. The whole suite is included; usage is the scaling axis, not headcount.
Add the whole team
Every engineer, no per-seat tax.
One API, included
Not a separate docs-platform bill.
Usage scales, not seats
Generous defaults; usage is the axis.
Straight about what's live.
We're pre-launch and we say so. Here's exactly where the developer surface stands today, and what lands before anyone's let in.
-
Publish-your-own developer portal — OpenAPI 3.1, rendered reference, "Try it" console, guides, version diff, export to JSON / YAML / Postman, and
/llms.txt. - Org API keys for heartbeat pings and custom-metric ingest.
- The full REST API over support, incidents, monitoring, and status.
- MCP server + REST API — connect your own agent at individual / system / customer scope.
- Incident auto-resolve / auto-close.
Get in early — and help shape the API.
We're building the developer surface with our first teams. Join the waitlist and you'll be among the first to build on it — and the limits and shape get set with people like you, not handed down.