From the Dashboard to the Product Where Work Begins

Six · 6 min read · July 30, 2026

From the Dashboard to the Product Where Work Begins

Say you look after the internal tool your account managers use to get ready for renewals. Two months before a contract ends, a manager opens the client's page and has to answer a few questions before the call. What did they buy, and how much of it do they use? What have they complained about since they signed? If they ask for a discount, do we have a reason to say yes?

Answering those can take an afternoon. Someone has to read the contract, go through the support tickets and compare how much they use it now with how much they used it a year ago. It's the kind of research you'd hand to your atoms. But without a connection, handing it over means the manager leaves the account page, opens Supanova, explains the client all over again and carries the brief back.

Your workforce has an API, a way for one product to ask another for work, so the account page could send that request itself. Before anyone builds that, decide what work should go from the account page to your workforce and what has to stay with the manager.

What stays with the manager

The manager is the one who'll lead that call. They decide whether the client sounds at risk, whether to offer anything, and how to explain it afterwards if the renewal goes badly. If the account page gets a "Prepare renewal brief" button, pressing it should bring back the research. Those decisions are still the manager's to make.

The Supanova dashboard is where you set up your workforce and keep an eye on it. You go there on purpose. The account page is where the manager already has the contract open and the call on the calendar. When the brief starts there, it starts with the person who'll answer for the renewal.

Draw the handoff before you build it

You don't need a technical diagram to start. Write the path in plain words:

The manager asks for a renewal brief on the account page. The request goes to your workforce through the API. Your atoms prepare the brief. The finished brief comes back for review. The manager decides what to say on the call.

The manager is in the first sentence and the last one. Walk the steps in between with whoever will build the connection, and answer the questions they raise.

What starts the request? A manager clicking a button is one thing. A brief that starts on its own sixty days before every renewal is another, because nobody asked for that particular brief and nobody may be waiting to read it.

What's the smallest piece of work that fits? "Prepare a renewal brief for this client" is one job you can review. "Handle the renewal" isn't.

What information crosses? The brief needs the contract terms, the tickets since they signed and the usage numbers. It probably doesn't need the manager's private notes from their last conversation with the client. Decide what goes before the developer has to guess.

What comes back, and to whom? The brief should reach the manager who asked for it, with enough time to read it before the call.

What does the manager need to check before the next step? If the brief says the client is at risk because tickets doubled, the manager should be able to find out which tickets, and whether they were all about the same bug.

A request to prepare a brief shouldn't grow into drafting the renewal email and sending it, just because the atoms on the other side could write one. The account page asks for renewal briefs, so that's all this connection should carry.

The door and the key

The API is a door from the account page into your workforce, and the connection needs a key to come through it. Who holds that key, and what should it open?

In Supanova, the connection gets its own key. For the account tool, decide what renewal briefs need that key to do, and nothing more. Then name the person who owns it, so someone answers for the key when the tool changes.

The key controls what comes through the door. It doesn't decide what the brief means, whether the client gets a discount or what the manager promises on the call. Those stay with the manager and with whoever sets the rules for renewals.

When the brief is done, the account page has to find out. If your developer uses webhooks (the messages one system sends another when something happens), GitHub advises subscribing only to the events you need and checking the event type and action before processing one. Here, that means listening for a finished renewal brief and checking which client it's for before showing it. Even then, "finished" only means the manager has something to read. Checking it is still their job.

What other tools answer

Your developer may ask why you wouldn't build this with tools they already know. Here's what a few of them are for.

A model API gives your product a model to call. To get a renewal brief out of it, your team builds the agent: what it reads, how it checks its work, where a person approves. OpenAI's Agents SDK is a kit for building agents like that, and your team still decides how its specialists work together and what state they keep.

An agent runtime helps your team run the agents it builds. LangGraph calls itself "a low-level orchestration framework and runtime for long-running, stateful agents," and lists ways to pause a run, inspect or edit its state, and carry on. That's how you could stop a brief halfway for the manager to look at, once your team has built the agent that writes it.

A workflow automation platform moves things between apps. In Zapier's description, a trigger starts a workflow when an item is added or updated in an app, and an action creates or updates an item. A new renewal date in one app could create a reminder in another. Somebody still has to write the brief.

Any of these leaves your team building whatever reads the contract, goes through the tickets and compares usage with last year's. With Supanova, the account page asks atoms you've already set up to do that research, and the finished brief comes back for review. You still decide what the manager should check in it before the call, because that depends on the client and how you handle renewals.

Start with one handoff

The first move is a map, not a plan to connect everything. For the account tool, it fits on one page:

If the team can fill in that page, you have a connection worth building. If a line stays blank, that's the conversation to have before anyone writes code.

Say the renewal brief ran on Supanova. The manager clicks once on the account page. The request carries the contract, the tickets and the usage figures, and nothing else. Your atoms do the reading and comparing. The finished brief comes back for review, and the manager reads it before picking up the phone. If the "at risk" verdict rests on a run of tickets about one bug that has since been fixed, the manager catches it there, not halfway through the call.

The renewal happens on the account page. Now the research can start there too.

Which screen in your business has someone waiting on work like this? Map that one handoff first, then see what your workforce can do.

Sources

autonomous-workforcehuman reviewProduct designPublic API