Skip to content
Back to blog

Enterprise6 min read

I didn’t build governance. I plugged into it

Ben Stump, PubNub’s CRO, built a dashboard app that only ran on his laptop. He explains how publishing it as a private agent on Blocks Pro turned it into shared, real-time, audited insight for leaders across the company, without asking IT for an exception.

Turning a private CRO dashboard into shared, real-time, audited insight, without asking IT for an exception.

Every morning for the past few months I've started my day with a dashboard app I built for myself. It pulls together the things a CRO actually needs before the first call: which accounts flipped status overnight and who owns them, book ARR against baseline, every account touched by the team in the last 24 hours and 7 days across Salesforce activity, Gong calls, and status notes, the customer meetings on today's calendar, the Slack signals worth knowing about, and a watchlist of at-risk and new opportunities closing in the next 45 days. There's a button that drafts a status report for any opportunity and another that builds a meeting-prep doc from Salesforce, Gong, and Zendesk. And there's an "Ask PubNub" box where I can type a question in plain English and get back records with source links from our MCP server, not a summary someone else decided I needed.

It was useful. It was mine and mine alone. It ran on my laptop, on localhost, with my credentials. When a peer asked "can I see that?" the honest answer was "come stand behind me or I grab a screenshot and slack it to you."

This post is about how that changed, and why the change matters far more than one dashboard app.

Building wasn’t the challenge, sharing was

The app itself was never the hard part. The data was already reachable through internal retrieval agents that sit in front of Salesforce, Gong, Zendesk, Slack, and Confluence and answer precise, field-level questions. My app asks that agent 20 or so narrow questions, parses the answers deterministically, and lays them out in an interactive app I designed with Claude. Every field the AI fills gets an "AI" badge and stays editable, so I can review and correct rather than trust blindly.

The hard part was everything after "it works on my machine." To let anyone else use it, I would have needed to host it somewhere, put authentication in front of it, decide how to manage who gets in, figure out how to revoke access when someone changes roles, and convince IT that a CRO-built side project touching CRM and half a dozen internal systems was safe to run. That is the wall almost every internal tool hits, and it is why most of them die on a laptop or, worse, get shared in ways nobody sanctioned.

How Blocks.ai helped

PubNub runs its own Blocks Pro instance: a private, single-tenant control plane for every AI agent in the company. I didn't have to build governance. I just had to plug into it.

The path was short: I wrapped the app logic in a thin handler using the open-source Blocks SDK, the same function-in, artifacts-out shape whether you write TypeScript or Python. blocks register published it as a private agent on our enterprise instance, invite-only by default. blocks run opened a single outbound connection from the machine where the agent lives. Nothing inbound, no ports, no public IP. The agent never moved and my data never left PubNub's systems.

Then I created two views. The private one is the full app, everything I look at in the morning including things that are only appropriate for me. The shared one is the same engine, scoped to what leaders across the business should see, published as its own private agent. I invited specific people across Sales, Customer Success, Engineering, Marketing, Product, and Finance. Anyone not on the list gets an access error at sign-in. Not a stripped-down view; no data at all.

For the front end, I scaffolded a web app with the Blocks CLI, kept the built-in "Sign in with Blocks" widget, and deployed it to Netlify. The page itself is public. That sounds wrong until you understand the model: the browser talks directly to our enterprise instance with the signed-in user's identity, and the agent decides whether that identity has a grant. The UI holds no secrets and no API keys. Authorization lives in one place, which is exactly where IT wants it.

Why IT said yes

This is the part I want other business leaders to understand, because it is the part that unlocks everything else.

Our IT and security team didn't have to review my code line by line to approve it. They govern the instance. Every agent at PubNub, regardless of who built it or what model it uses, is registered in the same private registry, visible in the same Admin Console, organized into the same business-unit organizations, and authenticated through the same SSO with group sync. The audit log records every control-plane event with user, action, timestamp, the resource affected, and a before-and-after diff: who registered the agent, who was invited, who accepted, who was revoked. If I leave, or if someone on the invite list changes roles, access is revoked with one command and takes effect immediately.

That is a very different conversation from "please let me run my script in production." IT didn't approve a dashboard or my app. They approved a system, Blocks Pro, once, and now every agent that lands on it inherits the same controls.

What changed for the people I invited to the app

The first week told me everything. A Customer Success leader saw an account status change and reached out before the customer's account manager had even finished reading the same signal. A Finance partner stopped asking me for the pipeline snapshot on Thursday afternoons and started pulling it on their own, when they needed it, with the same definitions I use. A Marketing leader used the Ask box to check inbound source mix against a campaign that went live the day before, and had an answer during the meeting rather than the following week.

None of those people had real-time access to this before. They had my weekly summary, or a Salesforce report they had to build themselves, or a Slack thread they had to hunt for. Now they have the same view I have, refreshed on demand, with source links they can click through to verify. Decisions got faster because the argument about whose numbers were right disappeared. They are the same numbers across the board.

The real value: Efficiency multiplier

One app shared with a dozen people is a nice story. It is not the point.

The point is that the path I walked is now the default path at PubNub for anyone with a spreadsheet, a script, or a question they answer repeatedly for other people or for themselves. A support lead can wrap their escalation triage the same way. A product manager can publish an agent that turns Gong transcripts into feature-request signals. A finance analyst can expose the forecast reconciliation they run every Monday. Each of them registers on the same instance, inherits the same SSO and audit trail, invites the people who need it, and puts whatever UI they like in front of it. They don't need to build an auth system. They don't need to ask IT for an exception. The governed path is the easy path, which is the only kind of governance that actually sticks.

And because every one of those agents lives on the same smart network, they can call each other. My digest already leans on a set of shared retrieval agents instead of new and separate integrations. The next agent someone builds can lean on mine, if they have access of course.

What you end up with is not a collection of dashboards or apps. It is an organization where the people closest to the work can package what they know, hand it to the people who need it, and do it inside guardrails the company set. More insight, in more hands, faster, with less risk than the laptop-and-screenshot world we all quietly lived in. That is what Blocks Pro did for us in days, and it’s what it will do for most companies that try it.