build-in-public

build-in-public

Our Own Agent Gets No Back Door

Our Own Agent Gets No Back Door

Our Own Agent Gets No Back Door

RC

Rob Catalano - Co-founder -

Rob Catalano - Co-founder -

-

-

4 min read

4 min read

Every software company that ships an AI agent faces the same temptation. The vendor's own agent is the demo. It has to be fast, it has to look smart, and it has to work on the first try. So it quietly gets privileges nobody else gets: a direct database connection, a looser permission set, a shortcut around the review step that "slows the demo down."

We made a rule that Operator, the reference agent included with wysdym, gets none of that. No private API. No elevated scope. No skipping the queue. It calls in through the same door your agents do, under the same rules, and it shows the same receipts. This piece is about why we made that rule, and what it forces on us.

The back door is where trust leaks

A vendor agent with special access proves one thing: that the vendor's agent works. It tells you nothing about whether yours will.

That matters more than it sounds, because most GTM teams are not running one agent. They run a vendor's agent, a few point tools, and something a RevOps engineer wired up on a weekend. If the governance only really applies to the agents the vendor didn't build, then the governance is a feature of the sales demo, not the product.

Buyers already sense this. Kyndryl's 2026 People Readiness Report found that only one in four leaders completely trust their AI systems, yet two-thirds have given AI write access to core systems. Autonomy is running ahead of trust. A vendor that exempts its own agent from the controls widens that gap instead of closing it.

What "no back door" means in practice

Operator is, architecturally, just another agent. Here is what that looks like on wysdym (the five pillars are laid out at wysdym.ai/platform):

  • Same door. Operator calls into the Gateway over MCP, the same surface a customer-brought Claude, OpenAI, or LangGraph agent uses. There is no second entrance.

  • Same identity rules. It has its own agent identity and its own permission scope, set by the same per-agent access controls you set for everything else.

  • Same capabilities. It does its work by invoking Skills against Cortex, the shared intelligence and memory layer, and your connected systems. If a Skill doesn't exist, Operator can't do the thing either.

  • Same rules on writes. CRM writes go through the write-approval queue, which is default-deny. Changes to the graph go through human review. Operator proposes; a person approves.

  • Same receipts. Every Operator answer carries a provenance footer showing what it touched, and its actions are traced in Observe alongside every other agent on the stack.

If the operating layer can run our agent under those constraints, it can run yours. That is the whole argument, and we would rather make it with architecture than with a slide.

What the rule costs us

Building this way is slower in the short term. Being honest about the trade-offs is part of the point.

We can't fake a capability. When Operator needs to do something new, the fastest path would be a one-off integration that only it can call. The rule says no. We build it as a Skill, which means it has a typed contract, it runs through governance, and it becomes available to any agent a customer connects. The work goes into the shared layer, not into our agent.

We feel the friction first. If an approval step is clumsy, a permission is too coarse, or a provenance footer is confusing, we hit it before anyone else does, because our own agent lives under the same constraints. That is uncomfortable. It is also the cheapest product research we will ever get.

The demo is less magical. An agent with a back door can do anything on stage. An agent that has to queue its CRM writes for human approval looks more careful. We think careful is what a CRO actually wants to see before letting anything write to their pipeline, but we have given up a little theatre to get there.

Controls that are built in, not bolted on

There is a broader lesson here for anyone evaluating agents, not just ours.

IBM's Institute for Business Value found that organizations with embedded, automated controls deploy 16x more agents than those governing manually. Read that the right way round. Governance done well isn't what slows agent adoption down. It's what lets it scale. The teams moving fastest are the ones whose controls apply everywhere by default, so nobody has to negotiate an exception for every new agent.

Exceptions are where that breaks. Every "this one is special" agent becomes a second policy to maintain, a second audit trail to reconcile, and a second place where something can go wrong without anyone seeing it. One rule for every agent is easier to reason about, easier to audit, and easier to trust.

Four questions to ask any vendor's agent

If you are evaluating agents for your GTM stack this quarter, ask the vendor these about their own agent, not just their platform:

  1. Does your agent connect through the same interface and permission model that third-party agents use?

  2. Can it write to my CRM without a human approving the change? Who can turn that on, and where is it logged?

  3. Can I see what it read and what it changed, for every answer?

  4. If I disconnect your agent tomorrow, do my other agents lose anything it learned?

A vendor whose own agent passes those questions has built governance into the product. A vendor whose agent is the exception has built a demo.

That is the bet underneath wysdym. Don't bet on the agents. Bet on what every agent needs to work, including ours. If you want to see Operator running under the same rules as everything else, book a conversation with the founders at wysdym.ai.

Enjoyed the read? There’s no book on agentic GTM.

Enjoyed the read? There’s no book on agentic GTM.

Enjoyed the read? There’s no book on agentic GTM.

so we’re writing it weekly

so we’re writing it weekly

“pearls of wysdym”, weekly, 5 min read, free