← /posts

Engineering

Nobody is going to open your dashboard

How we rebuilt Gurusup so you can run all of it from your own Claude or ChatGPT, and where the product decisions that used to live in our screens went instead.

Author
Nacho González
Published
Oct 22, 2026
Reading time
11 min

Interfaces have changed, and Gergely Orosz isn't the only one saying it. On the same day this October, Theo (t3.gg) wrote: "If I have to go to a dashboard to use your product, I'm not going to use your product." Ben Hylak wrote that every product he uses should be a headless MCP feeding his agent, "except for our product, of course. In our product, customers love the UI."

Ben's is a joke, and it's the honest part. Plenty of teams agree with Theo and quietly act like Ben. We had a web app with an onboarding flow and a lot of screens, and we were about to make the same exception for ourselves.

Then we asked what people actually pay us for. It's the service: a memory of the company that stays current, and agents that do real work with it. The screens are one way to reach that, and for people like Theo not the one they'd pick. So the product should work wherever they already are.

We went the other way. In Gurusup, the operations behind the web app, 147 of them today, can be called from your own Claude or ChatGPT, from connecting sources to switching on agents. The web app is still there. You just don't have to go to it.

Quick vocabulary before we start. Sources are the tools we read from, like Slack, Drive or Linear. The memory is what we build from them. Skills are written procedures. Agents use the memory and run skills, either when you ask or on a schedule; a scheduled task is a job.

The UI was where we kept our opinions

A UI is also where a product team stores its judgment: the order of the onboarding steps, which option is selected by default, the warning before something risky, the button that isn't there because we didn't want you to press it.

Take the screens away and that judgment needs a new home. Our first instinct was to move it into the instructions we give the assistant, as a long list of "always do this, never do that". The assistant got rigid. And a rule in a prompt is still a suggestion: nothing stops a model from skipping it on a bad day.

So we split it in two, and kept coming back to that split for the whole project:

  • Guardrails go in code: anything that must not happen is enforced by the server, whatever the assistant decides.
  • Context goes in prose: everything else gets explained: what Gurusup is for, and what each choice means for the person.

The architecture

MCP-FIRST ARCHITECTUREyour assistantClaude · ChatGPTGurusup MCP/mcp: 4 tools/mcp/directory: one eachweb appAPIssame as the web app+ the guardrailsmemoryagentslinkconnect pagekeys · OAuthkeys and authorizations never pass through the chat

There are four pieces:

  • The person's assistant: Claude or ChatGPT, with whatever it already knows about them: their connectors, memory and skills.
  • Our MCP server: it signs the person in with OAuth, describes what can be done, and formats answers for the assistant. It holds no business rules of its own.
  • The APIs: the same ones the web app uses, for the product and for the agent harness, with the same permissions. Every guardrail lives here, so it holds whether the request comes from a screen or from a chat.
  • A few web pages: only for the steps that should never happen inside a chat: entering an API key or authorizing an account.

That third point is the decision we'd make again. The MCP server is one more client of the same APIs. If we change which edits force a job to be reviewed again, we change it once in the harness and the web app, the MCP and our own internal agents all follow. A CLI tomorrow would need its own experience and sign-in, and nothing more.

A catalog instead of a hundred tools

The obvious way to expose 147 operations is 147 tools. Every new capability becomes one more entry in the list the assistant loads before it does anything, and that list only grows.

So the main endpoint, /mcp, adds four generic tools next to our usual ones: learn explains how to do a flow, discover finds operations and returns their contract, query runs reads and execute runs changes. The full catalog stays on the server, and the assistant pulls in the piece it needs:

FROM 147 OPERATIONS TO ONE CALL147 operationson the serverdiscover()≤ 20 summariesdiscover(search)≤ 20 matchesdiscover(operation)one contractquery · executethe callfiltered by role at every step; the API checks again on execute

A search returns up to 20 summaries and a has_more flag, already filtered by the caller's role. Only when the assistant asks for one operation does it get the full schema of its arguments and response. Filtering by role only decides what the assistant sees. The API checks permissions again when the call runs.

The difference shows up before the first call:

WHAT THE ASSISTANT LOADS BEFORE ITS FIRST CALLlearn · discover · query · execute≈ 3.2 KB/mcp, all 21 tools≈ 25 KB/mcp/directory, 165 tools≈ 213 KBsize of the tool list in JSON, not tokens; measured locally as an admin

Those numbers are JSON sizes; how many tokens they cost depends on the client. The catalog file itself is close to 40,000 lines and never leaves the server. This lowers what the assistant loads up front; it doesn't promise fewer tokens on every task, because a conversation keeps the contracts it looks up. Sometimes discover costs an extra step. We think a smaller starting point is worth it.

Where the catalog comes from

Nobody writes the catalog by hand. FastAPI already derives input and output schemas from our Pydantic models, so the only thing we add to a route is a line saying it should be exposed:

@router.post(
    "/v1/agents/{agent_id}/jobs",
    response_model=JobView,
    status_code=201,
    openapi_extra={
        "x-brain-operation": {
            "name": "jobs.create",
            "effect": "write",
        }
    },
)
async def create_job(agent_id, payload: JobDefinition, actor, store, idempotency_key):
    return await store.create(actor, agent_id, payload, idempotency_key)
The route that creates a job. Arguments come from JobDefinition, the response from JobView.
WHERE THE CATALOG COMES FROMAPI routex-brain-operationOpenAPIapp + harnessmakemcp-catalogoperation_catalog.json/mcpdiscover · query · execute/mcp/directoryone tool eachCI and deploy fail if it driftsunmarked routes stay out of the catalog

make mcp-catalog exports OpenAPI from the code, without starting servers or databases, and writes the catalog. It's committed next to the API change. CI and the deploy scripts run make check-mcp-catalog and fail if someone changed a contract and forgot to regenerate it; they never rewrite it on their own.

Exposure is explicit. A route without the marker stays out, which is how we keep things that only make sense in the web app, or only for internal processes. An operation can also be limited to certain roles.

One catalog, two shapes

ChatGPT's app guidelines don't allow a generic "run any operation" tool. So there's a second endpoint, /mcp/directory, that reads the same catalog and announces every operation as its own tool (jobs.defaults becomes jobs_defaults), each with its own description and readOnlyHint / destructiveHint annotations.

The URL decides the shape. Any client can use either one, and both go through the same execution adapter, so there's no second copy of the contracts or the rules. Our tests run the same operations through both endpoints.

We took ideas from Samuel Colvin's OpenArtifact, which shares MCP tools between its own agent and outside clients, and from the MCP servers of WorkOS and PostHog.

One request, end to end

This walk-through is built from real calls in our end-to-end tests, with ids replaced and responses shortened. Someone asks their assistant for a product summary every Monday at 9:

ONE REQUEST, END TO END“a product summary every Monday at 9”assistantGurusup MCP + APIslearn(topic="agents")how agents and jobs workdiscover(operation="jobs.create")arguments and responsequery("jobs.defaults")timezone: "Europe/Madrid"execute("jobs.create", request_id)job created: paused, review requiredquery("jobs.get")saved config and state

The call that creates it looks like this:

{
  "name": "execute",
  "arguments": {
    "operation": "jobs.create",
    "request_id": "weekly-product-summary",
    "arguments": {
      "agent_id": "AGENT_ID",
      "body": {
        "name": "Weekly product summary",
        "instructions": "Write a short product summary with the sources you used.",
        "schedule_kind": "calendar",
        "calendar_days": [1],
        "calendar_hour": 9,
        "calendar_minute": 0,
        "timezone": "Europe/Madrid"
      }
    }
  }
}

The harness created the job paused, with a reviewed test required. The MCP passed that decision on; it didn't add an approval policy of its own. Creating the job doesn't switch on its schedule: there's still a test to run and review. Not every task needs all four tools either. If the assistant already knows the procedure and the contract, it reuses them.

Context: what the assistant reads first

Every session starts with init. It's short on purpose: a few sentences on what Gurusup is for, where to start and where the boundaries are, plus a checklist built from the real state of the organization. It also says, in so many words, that "a queued request or a complete setup checklist is not authorization to activate work".

The longer guidance lives in four playbooks, getting started, knowledge, agents and the organization, which the assistant loads with learn when it needs them. We wrote them the way we'd brief a new colleague on day one: what the product is for, make a proposal the person can react to, explain the consequences before acting.

The part about what the product is for was added late, and it changed behavior more than any rule did. An assistant that understands the purpose makes reasonable calls in situations nobody wrote down.

The checklist means the assistant never has to remember where it left off. Connecting sources and building the memory are core; skills, agents and apps are optional, so using only the memory is a complete setup. Once an agent exists, a tested agent becomes required.

The onboarding flow

MCP-FIRST ONBOARDINGinitguide + checklistlook beforeaskingoneproposalsources, historymemory builddraft skillspropose agents+ their accesstest · reviewactivateafter one proposal, three tracks run in parallel

Our web wizard asks every new user the same questions. Your assistant may already be connected to your email, calendar and issue tracker, and may know how you write. So it can skip most of the questions:

  • Start: the assistant calls init and gets the guide and the checklist.
  • Look before asking: it uses what it already knows about how the person works, and asks only what it can't infer.
  • One complete proposal: sources to connect so the memory stays current, agents that would take work off their plate, and the jobs those agents would run. The person accepts, edits or skips.

After the proposal, three tracks run in parallel:

  • Sources and memory: the person connects each source on our page, opened from the chat. For the sources that support it, the last 30 days of history come in by default, up to 100,000 tokens per organization across those automatic imports. More can be imported explicitly later. When history arrives this way, the first memory build starts on its own.
  • Skills: it drafts skills from the person's real processes.
  • Agents: it proposes agents, including what knowledge each one may see.

The tracks meet at the end: every agent job runs a test, the person reviews it, and only then can it be switched on.

Guardrails: what the server enforces

Jobs start paused

JOB LIFECYCLEcreatedpausedtest runreviewedthis versionserver checkactivejob edited: needs a new review

A job created from a chat starts paused and marked as needing a reviewed test. The review is tied to the version of the job's behaviour: change its schedule, instructions or destination, or the agent's apps or skills, and it needs a new review. Renaming it doesn't. Try to resume a job without a reviewed test and the server refuses.

Other guardrails

  • Retries don't duplicate work: assistants retry. execute takes a request_id, and operations that start work, like creating a job, running one now or messaging an agent, use it as an idempotency key, so a retry doesn't run them twice.
  • Agent permissions are admin-only: what knowledge an agent can see is the first thing the agents playbook covers, and only admins can change it. An agent that runs on a schedule keeps using that access when nobody is looking, so widening it is an organization decision.
  • Privacy is decided when connecting: a source can be just yours, shared with specific people, or open to the whole organization. Apps can be connected for yourself or for the organization, and with more than one account.

Keys never go through the chat. When the client supports it, the assistant opens our page directly; otherwise it sends a link. A link from a chat creates a new problem: anyone who gets it could open it. So each one is signed and expires after 30 minutes. The signature covers the request that created it, the organization and the person, and our page checks that whoever is signed in is the person who started it before showing anything.

Debugging an agent without opening the box

If people run their agents from their assistant, they'll also debug them from there. "Why did my agent answer that?" needs a real answer.

The assistant can read a trace of any run: the steps taken, the documents cited, the apps called on the person's behalf, and where the agent stopped to ask a human. What it doesn't get is our internals: prompts, internal skills, which model ran it, or our infrastructure.

The trace is built from an allowlist: each field that appears was chosen on purpose, so anything we add internally later stays private by default. Fields that look like secrets are dropped, and a failed run reports one of seven fixed reasons.

How we test it

Assistants are very good at saying they did something. So the test for the whole flow never asks them.

Unit tests cover the guardrails. For the flow itself we built an end-to-end eval:

  • One model plays the assistant, through a ChatGPT-style client connected to our real MCP server and APIs running locally. Connecting a source is simulated; everything after that is real.
  • Another model plays a founder who knows nothing about how it's built and asks in plain words.
  • The verdict comes from the state of the organization read back from the API: a connected source, a memory build requested, an approved skill, and an agent with a reviewed test and its activation requested.
  • It fails if the founder needs more than six inputs, or if the first review takes longer than ten minutes. It also scores, from 0 to 5, how well the agent's draft matches the founder's writing style.

Before calling it done, we also ran the whole thing by hand from a brand-new email, once in Claude Code and once in ChatGPT.

What we haven't solved

  • Telling you when long work finishes: building the memory takes minutes. Today the assistant checks back, and sometimes it waits for you to say "check again". ElevenLabs, Emergent and Chatbase, the MCP-first products we looked at, don't notify you either. The Tasks extension in the next MCP revision should help.
  • Contracts pile up: discover keeps the starting list small, but every contract the assistant looks up stays in the conversation. On a long session that adds up.
  • Agents that run unattended: an agent that reads untrusted input, can see private data and can send things outside the company is what Simon Willison calls the lethal trifecta. One reviewed test doesn't make that safe without a person watching. We haven't decided what does yet.
  • Proving it's faster with real people: the eval's bar is ten minutes to the first review. We'll publish a number once we've measured it with real people.

Back to the joke

Ben's post works because plenty of teams think their UI is the exception. Ours might have been. But the more of Gurusup we made usable from someone else's assistant, the clearer it got where our moat is: the memory, the agents, and the rules that keep them safe. The interface in front of them is the part we can afford to let go.

Use it from our web app, from Claude, from ChatGPT, or from whatever you're using next year. We still maintain the web app. We just stopped designing the product around it.

guest@gurusup > /posts

guest@gurusup > /install · connect Gurusup Brain to your agents

Get started - free