RC
The first real question a GTM leader asks on a call with us is never "what does it do." It's "what actually works today." Most vendors answer that with a demo. We answer it with a ledger.
This post is that ledger. It covers what's live on wysdym right now, what's still in development, and why we publish the second list at all. It's written for the practitioner who has been burned by a roadmap slide before and would rather see the seams than be sold around them.
Why the order of the build matters more than the feature list
The agentic AI market has a production problem, not a demo problem. Capgemini's April 2026 research puts it bluntly: 95% of AI agents never make it to production. An earlier Capgemini study found only 2% of organizations have fully scaled agentic deployment, even though 93% of leaders believe scaling agents would give them an edge.
Read those two numbers together and the lesson isn't "build a better agent." The agents mostly work. What fails is the layer underneath them: the connections into the systems where revenue lives, the visibility into what an agent actually did, the rules on what it's allowed to write, and the memory that lets the next agent start smarter than the last.
So we built bottom-up. Connections and observability first, because you can't govern or learn from what you can't reach or see. Then the graph and the governance primitives, because a shared memory with no rules on who writes to it is a liability. Then a working agent on top, because an operating layer with nothing running on it proves nothing. The sequence is the strategy. wysdym is the operating layer for agentic go-to-market, and an operating layer has to be built in the order the stack actually depends on it.
What's live today
Status as of this writing. Everything below maps to code that's merged and running, not to a prototype.
The five pillars, connected through the Gateway. Cortex (shared intelligence and memory), Skills (what agents do), Governance (the rules on every action), Observe (which agents are actually working), and Operator (analyst-grade answers that act on your workflows) are live and shipped as one governed harness.
wysdymGraph is in production. A per-tenant, typed GTM knowledge graph: offerings, target buyers, competitors, pain points, objections, talk tracks, proof points and the relationships between them, with tenant isolation enforced at the database layer. This is the Cortex pillar in concrete form.
Connections wired once, through the Gateway. Salesforce, HubSpot, Gong, Slack, and Notion are connected through one door, with OAuth and token handling abstracted so no long-lived credentials sit in our stores. Every agent on the layer inherits the same connections instead of re-wiring its own.
Governance primitives. A write-approval queue with a default-deny policy, a human-in-the-loop review queue, and an audit trail on every action. Agents propose the write. A human approves it before it touches your CRM.
Observe. Per-agent reporting, session analytics, and outcome attribution designed around deal stages rather than tokens and latency.
Operator. The included reference agent, live in-app. It reads from your graph, runs typed skills, writes through the approval queue, and shows its provenance on every answer. It's the daily proof that the layer works, because it runs on exactly what your own agents run on.
That's the read, run, write, learn loop, end to end, on real tenants.
What isn't, and we'd rather you hear it from us
Plays are coming. Plays are routines that chain skills together, each tied to a measurable deal outcome. The surfaces and architecture exist; the scheduler that runs them at production scale on live signal is the near-term build. [ROADMAP]
Findings at production scale are in development. Findings are the drift alerts: a deal going quiet, a champion changing, a qualification slipping, each surfaced with evidence and the exact CRM write the layer would make. The engine that fires them continuously across every agent you bring is being built now. [ROADMAP]
The Observe SDK for auto-instrumenting third-party agents (Anthropic, OpenAI, LangChain, LangGraph) so outcome attribution spans agents we didn't build. In development. [ROADMAP]
Operator in Slack and Teams. The channels are already wired through the Gateway; the in-channel agent surface is next on the roadmap. [ROADMAP]
We're not listing these to be modest. We're listing them because a GTM leader evaluating an operating layer needs to know which parts of the loop they're betting on today and which parts they're betting on us to finish.
Why we publish the second list
Look at the "not yet" list again. Plays, Findings at scale, cross-vendor attribution. Every one of those is a feature whose correctness depends on live signal: real deals moving through real pipelines, real agents from more than one vendor writing through the same queue, real reps overriding a proposed CRM write and saying why.
You cannot finish those features in a lab. You finish them against actual agent traffic and structured feedback from the operators running it, and you publish what changed. That's why the ledger exists, and why it will keep getting updated as items move from the second list to the first.
It's the same motion the founding team ran at Achievers and at WorkTango. Get the foundation solid, then put it in front of demanding operators before the feature list is complete, and let their pipelines decide what ships next. It's slower than selling a finished slide. It produces a much better product.
The thesis hasn't changed since the first post we published: don't bet on the agents, bet on what every agent needs to work. What has changed is that the foundation is now live enough to bet on, and the remaining work is the part that's better built with you than for you.
If you run GTM at a B2B company and already have more than one agent touching your stack, we'd like to compare notes on what the layer underneath them should look like. Talk to the founders at wysdym.ai, and the ledger above is exactly what you'll be looking at.
