API and MCP

Debug a failed run from your editor.

Ask why last night's job failed. The assistant reads that run itself, under your own token, and tells you which node broke. The same routes feed the dashboard your team already watches.

The problem

People guess instead of looking.

A job fails overnight. You find out the next morning, in your editor, in the middle of something else.

Looking it up means dropping what you're doing and going to find the run. Most people don't. They rerun it and watch, or read the code again hoping something jumps out.

It's the same for the team. Run status sits in dagweave, and the alerting everyone already watches never hears about it.

In your editor

The assistant reads the run itself.

You're in the editor with the code open. Ask what happened, and the assistant pulls the run, the node that failed and the error.

It runs under your own token. The model sees what you can see.
One POST endpoint and the token you already have. Nothing to stand up, nothing to keep alive.

one JSON-RPC request per POST text

dagweave_list_runs           limit, offset, includeTest
dagweave_get_run             node detail, artifacts, logs
dagweave_list_workflows      q, label, namespace, folder
dagweave_list_audit_events   action, actor, outcome, from/to

handshake and tool list      free against the rate limit
a tool call                  the same budget as its HTTP route

Your dashboard

Feed the dashboard your team already watches.

Nobody adds a tab to watch for a failure. Pull run status over HTTP and it lands in the dashboard and the alerting you already run.

A failed run carries the node that broke and its error on the list row. One call fills in the alert.
Add format=csv to the audit log and it comes back as an attachment, ready for a reviewer.
A poller knows when to back off.

bearer token, every v1 route text

GET   /api/v1/runs            runs:read
GET   /api/v1/runs/{id}       runs:read
GET   /api/v1/workflows       workflows:read
GET   /api/v1/audit           audit:read
POST  /api/v1/mcp             a live token, then each tool's own scope

once a request authenticates:
  X-RateLimit-Limit / Remaining / Reset, and Retry-After on a 429
  a 401, or a 403 across teams, carries none of them

Blast radius

A token reads what its owner can read.

You want to know the worst case before you hand a token to a dashboard or an assistant. The worst case is a read of what that person could already open in the app.

Every route reads. A token can't start, change or delete anything.
Issued per person. Revoke one and one integration stops, not the team.
Scoped. A status dashboard gets run status and nothing else.
A route can't be more permissive than the same button in the app.

token text

dwk_...   a fixed prefix a scanner can catch
          shown once, stored only as a sha256 hash
scopes    runs:read, workflows:read, audit:read
expiry    1 to 730 days, or open until you revoke
revoked   dead on the next request, checked live not cached
minting   only from a real session, never from a token
offboard  the holder leaves the team, the token stops

Wire it into your own tools.

dagweave is in early access. Leave an email and we will bring you on as we open it up.