I see customer conversations as a goldmine for every team—yet too often, they’re trapped inside the support platform. That silo makes it harder to make confident, customer-first decisions across product, sales, marketing, and leadership. I’ve felt that pain firsthand, which is why this update matters.
From today, the new Intercom connector for ChatGPT changes this. Intercom customers can now allow all teams to securely access conversations, tickets, and user data directly inside ChatGPT. Without having to switch tools, you can now get all the context you need to put the customer first across every area of your business.
Here’s how I approach it in practice: when frontline insights are accessible in the same workspace where I ideate, plan, and write, my team moves faster with more conviction. It’s the difference between guessing at customer needs and grounding decisions in real conversations.
How to connect Intercom to ChatGPT
Connecting Intercom to ChatGPT is easy:
1. In ChatGPT, open Settings → Connectors.
2. Search for “Intercom” and select it.
3. Sign in with your Intercom account to approve the secure connection.
(The connector is read-only and respects your existing Intercom permissions, so people only see what they already have access to. See more about security and setup details here.)
Once you’re in, you can start exploring your customer data using prompts written in natural language, like:
“Help me prepare for a meeting with customer X by updating me on outstanding issues raised in the last four weeks.”
“Find positive Intercom conversations mentioning our new feature Y, and add customer quotes to my campaign brief in Drive.”
“Build a list of the most common feature requests based on customer inquiries.”
What this unlocks
Connecting Intercom to ChatGPT makes customer feedback available across the company in a usable way. In my own workflow, this turns previously buried signals into actionable inputs for roadmaps, messaging, and enablement—without hopping between tools.
Support tickets contain direct information about what’s breaking, what’s confusing, and what people actually need. Normally, that information stays siloed in the support team. When I can query those conversations in plain language, I get immediate clarity on friction points and opportunities, and I can share that context with cross-functional partners in minutes.
When anyone can query it in plain language, it becomes useful for decision-making across the board. Teams stop working at cross-purposes because they’re looking at different parts of the picture. Now, product can see what’s actually frustrating users. Sales can understand common objections. Marketing can use the language customers actually use. Leadership can spot trends as they’re happening.
My recommendation: establish a lightweight ritual around this data. For example, build a weekly highlights digest sourced from Intercom conversations and review it in your product sync or go-to-market standups. It’s a simple way to align stakeholders and keep customer reality front and center.
We’ll be adding more connectors soon so you can access Intercom data in other AI tools your team already uses.
I’m constantly looking for ways to turn messy, multi-source signals into decisions leaders can trust. Recently, I dug into how Zencity powers government decision-making with community voices—and it’s a masterclass in building AI products that are both responsible and useful.
Noa Reikhav, Head of Product, Zencity; Andrew Therriault, VP of Data Science, Zencity; and Shota Papiashvili, SVP of R&D, Zencity share a comprehensive view of how they designed an AI that listens and acts without sacrificing rigor.
How do you use AI to help city leaders truly hear their residents?
I was struck by the clarity of their platform vision—“They share how Zencity brings together survey data, 311 calls, social media, and local news into a unified platform that helps cities understand what people care about—and act on it.” That single line captures the essence of a unified analytics platform done right.
You’ll hear how the team built their AI assistant and workflow engine by being thoughtful about their data layers, how they combined deterministic systems with LLM-driven synthesis, and how they keep accuracy and trust at the core of every AI decision.
It’s a fascinating look at how modern AI infrastructure can turn noisy, messy civic data into clear, actionable insight.
Here are the takeaways that resonated with me most, and they align closely with how I approach AI Strategy and product management leadership. Data architecture defines what AI can do. Guardrails and transparency matter more than flashy outputs. Agentic systems become powerful when grounded in real, multi-tenant data. AI in the public sector can make democracy more responsive—if built responsibly.
The team’s layered data model is the backbone that enables trustworthy synthesis: raw data → elements → highlights → insights → briefs. As a product leader, I love how each layer introduces meaning and structure while preserving traceability. It’s the difference between a demo-friendly prototype and a durable platform.
Why context is everything when building AI for civic use. That’s not a platitude—it’s a requirement. Community conversations are hyper-local, emotionally charged, and policy-laden. Without context and rigorous data governance, you risk misclassification, bias, and broken trust.
How the team designed their AI assistant using MCP servers to safely negotiate data access. This is a smart pattern for privacy-by-design: let the assistant request access, let the system adjudicate, and make the boundary explicit and auditable. In multi-tenant environments, that clarity is the difference between scaling confidently and shipping risk.
Balancing agentic flexibility with deterministic trust. I’ve found this to be the most practical framing for real-world agentic AI: give the system room to explore, but bind its outputs to deterministic rails where it matters—taxonomy, citations, permissions, and evaluation criteria.
Evaluating accuracy when latency matters: how they think about evals, citations, and model-as-judge systems. I appreciate the pragmatism here. In production, you don’t have the luxury of slow truth-finding. You need tight feedback loops, interpretable citations, and layered evals to keep both precision and speed.
Using workflows like annual budgeting or crisis communication to deliver AI-generated briefs to the right people at the right time. This is where product-market fit shows up: not in features, but in end-to-end workflows aligned to real decision cycles and stakeholders.
Why government workflows are the ultimate “jobs to be done” framework. When the job is a public process—with deadlines, accountability, and high scrutiny—you don’t just need insights; you need timely, contextualized briefs that match the cadence of the work.
From my lens, the magic isn’t any single model. It’s the orchestration: deterministic systems with LLM-driven synthesis, strong guardrails, transparent citations, and an orchestration layer that routes the right brief to the right role at the right moment. That’s how you turn community noise into legitimate signal—and signal into action.
If you’re building AI for regulated, high-stakes environments, take note: invest in your data layers, make context a first-class citizen, embrace privacy-by-design with clear access negotiation, and treat evaluation as a living system. Do that, and you’ll earn the trust that makes your AI assistant—and your organization—indispensable.
Go hard early is more than a mantra—it’s a product strategy. When I study the most durable enterprise companies, I see the same pattern: you win by shipping fast, obsessing over the customer’s day-to-day pains, and delivering consumer-quality experiences to business buyers. That lens is exactly why Serval’s recent momentum caught my attention and why the lessons behind it matter for every product and IT leader building in AI.
Jake is the founder and CEO of Serval, an AI-driven IT automation and service management platform that just raised $47M in Series A funding this week. Before founding Serval, Jake spent over five years at Verkada, where he led multiple products from 0-1 and helped scale the company across hardware and software. His years at Verkada taught him that winning in enterprise means delivering consumer-quality experiences to business buyers — a lesson that shapes how Serval turns complex IT automation into something that feels magical.
From my vantage point, the most counterintuitive lesson here is the power of building “in existing categories.” Rather than inventing a new market, the better move can be to redefine expectations inside a known one—where buyers, budgets, and success criteria already exist. That’s how you compress sales cycles, build trust rapidly, and create a wedge for product-led growth without boiling the ocean.
Another playbook thread I admire: turning “hard mode” into a moat. The teams that lean into gnarly integrations, real workflow depth, and enterprise-grade reliability end up compounding an advantage that’s very hard for fast followers to copy. That mindset shows up in Serval’s platform strategy and, more importantly, in how they translate complex IT work into something that feels intuitive on day one and powerful on day 100.
Customer intimacy sits at the center of that strategy. The customer interview question that unlocked the IT buyer’s hidden pain points is the kind of move I try to operationalize across product trios and forward-deployed teams. When you ask not just, “What do you do?” but, “What do you do when everything breaks?” you surface the real constraints: shadow runbooks, brittle scripts, brittle processes, and the political friction that slows down response times. That’s where durable value—and competitive differentiation—lives.
How Serval’s automation builder uses AI to generate code-based workflows is a particularly smart architectural choice. Code-first doesn’t mean hard-to-use; it means source-controlled, interoperable, and shareable across teams—exactly what IT leaders want when automation moves from side project to system of record. Tie that to agentic orchestration and you get reliable automations with clear observability, safety rails, and the ability to scale without collapsing under edge cases.
I’m also a believer in redefining engineering and PM roles with forward-deployed engineers. When engineers partner directly with customers, discovery accelerates, prioritization sharpens, and product bet quality improves. You avoid ping-ponging requirements through layers, and you raise the hiring bar for true product creators who can think in outcomes, not just output.
Keeping the hiring bar high in an AI-native startup isn’t optional—it’s existential. The best teams screen for candidates who can reason from first principles, ship quickly with taste, and articulate the value proposition in plain language. The ultimate hiring litmus test is whether someone can improve the product on day one by clarifying a user journey, simplifying a workflow, or tightening a metric that actually matters.
There’s also Why there’s a “land grab” moment right now in enterprise AI. Incumbents are strong on breadth but often slow to re-architect for AI-native workflows. New entrants that show up with opinionated defaults, pragmatic security, and crisp buyer narratives can establish points of parity quickly while extending into true points of differentiation. That’s the window to seize—especially when building for mid-market and enterprise.
Here are the core themes I took away and how I translate them into practice across product roadmapping and sprint planning, product discovery, and go-to-market strategy.
Why building “in existing categories” can be more powerful than creating new ones. Use the market’s mental models, measure against known alternatives, and win by delivering a meaningfully better experience—not by forcing buyers to invent new procurement paths.
The lessons from Verkada that shaped Serval’s platform strategy. Treat UX polish as a strategic asset, make setup effortless, and let power users go deep without friction. Consumer-grade quality is not a veneer; it’s a trust accelerator in enterprise.
The customer interview question that unlocked the IT buyer’s hidden pain points. Go beyond happy-path discovery. Ask about the 3 a.m. moments, the panic buttons, and the messy handoffs—then design for those first.
How Serval’s automation builder uses AI to generate code-based workflows. Pair AI generation with reviewability, versioning, and safe rollbacks. Make it easy to see, test, and share what the agent is doing under the hood.
Redefining engineering and PM roles with forward-deployed engineers. Collapse feedback loops by putting builders where the problems are. It’s the fastest path to product-market fit lessons and real-world reliability.
Keeping the hiring bar high in an AI-native startup. Look for taste, speed, and ownership. Optimize for people who can both prototype with gen ai and ship production-hardened systems.
Why there’s a “land grab” moment right now in enterprise AI. Move quickly, but anchor on outcomes. Land with a wedge use case, expand with measurable value, and maintain clear points of parity while you deepen differentiation.
If you want to follow or explore the companies and leaders referenced, these links are a useful starting point.
This podcast on all platforms: https://review.firstround.com/podcast
References:
Alex McLeod: https://www.linkedin.com/in/alexmcleodio/
Clay: https://www.clay.com
Cloudflare: https://www.cloudflare.com
Cursor: https://cursor.sh
Filip Kaliszan: https://www.linkedin.com/in/kaliszan/
Hans Robertson: https://www.linkedin.com/in/hansrobertson
Linear: https://linear.app
Okta: https://www.okta.com
Rippling: https://www.rippling.com
Serval: https://www.serval.com/
ServiceNow: https://www.servicenow.com
Verkada: https://www.verkada.com
Workday: https://www.workday.com
Timestamps and topic highlights for easy navigation and deeper study:
(02:25) Lessons from holding different product roles
(07:29) Turning “hard mode” into a moat
(10:49) The early days of Serval
(12:59) Scratching the founder itch
(14:57) Unconventional interview techniques
(17:47) Solving core interview challenges
(21:10) Planning the early product roadmap
(23:03) The surprising power of patience
(26:12) Serval’s impressive technical advantage
(27:35) Disrupting legacy incumbents
(31:13) Building for mid-market and enterprise
(33:35) Serval’s enduring roadmap
(36:08) How to sell to an existing market
(39:16) The evolving role software plays
(43:55) Building for AI that didn’t exist yet
(49:49) Serval’s forward-deployed engineers
(58:31) The hybrid PM-GM
(1:00:27) “You can over-prioritize”
(1:02:48) The unexpected value of panic buttons
(1:04:50) What Serval looks for in new talent
(1:07:01) The ultimate hiring litmus test
(1:13:59) Building out Serval’s go-to-market function
(1:16:31) The evolving IT market in 2025
My bottom line: build where budgets already live, ship with uncompromising UX, embed engineers with customers, and hold the line on talent. Do that, and you won’t just keep up with the enterprise AI “land grab”—you’ll define the standard others have to meet.
I’ve been reflecting on How Pendo’s Summer Release reimagines onboarding, support, and expansion in the SaaS + AI era, and it resonates deeply with the product-led playbooks my team and I use every day. The core promise is simple and powerful: “These three best practices aren’t new, but how you achieve them is.” That framing captures the shift I see across high-performing product organizations—same outcomes, radically upgraded execution through AI, in-app experiences, and unified analytics.
For onboarding, I prioritize accelerating user activation with clear product tours, in-app guides, and great UX writing that removes cognitive load. The difference now is how precisely we personalize these moments: segmentation driven by product usage, CRM integration, and experiments (A/B testing with a disciplined minimum detectable effect) help us craft paths that meet users where they are. When onboarding is instrumented this way, it becomes a scalable engine for product-led growth rather than a one-time setup task.
Support is undergoing an equally meaningful transformation. Contextual, in-app help combined with agentic AI can diagnose issues, surface relevant knowledge, and guide users without forcing channel switches. I’m bullish on this, but only when it’s anchored in privacy-by-design, AI risk management, and strong data governance—trust is the prerequisite for any customer support AI strategy. When done right, support shifts from reactive ticket resolution to proactive value delivery.
Expansion, to me, is the earned outcome of consistent product value. In the SaaS + AI era, we can use unified analytics to identify readiness signals—feature adoption, outcomes achieved, and time-to-value—and trigger timely, ethical nudges in-app. The best motions align offers with real customer milestones, whether that’s consumption SaaS pricing upgrades, role-based add-ons, or advanced capabilities unlocked through demonstrated need. This is product-led growth at its most customer-centric.
Underpinning all three motions is measurement discipline. I push for a unified analytics platform that ties together behavioral data, retention analysis, funnels, and cohorts with downstream CRM integration. That allows product trios to make fast, informed decisions and connect activation, support efficiency, and expansion to business outcomes. Whether your stack includes Pendo, Amplitude analytics, or custom pipelines, the principle is the same—one source of truth that informs action.
Execution matters as much as strategy. Empowered product teams working in tight product trios can ship small, valuable increments, run clean experiments, and learn faster than the market shifts. Strong stakeholder management and clear product roadmapping keep leadership aligned on outcomes vs output OKRs, so we’re funding what works and pruning what doesn’t. In my experience, this operational rigor is what turns promising ideas into durable competitive differentiation.
If you’re looking to operationalize these ideas, start by defining activation and expansion milestones that map to your value proposition. Instrument your in-app guides and product tours to support those milestones, and commit to an experimentation cadence with well-defined MDE. Layer in agentic AI carefully—pilot in the support surface where context is rich and stakes are clear—and enforce privacy and governance from day one. Finally, close the loop with unified analytics so every improvement compounds.
Pendo’s Summer Release highlights a broader reality: our industry isn’t inventing new destinations, we’re modernizing the routes. Onboarding, support, and expansion remain the pillars—but AI, in-app experiences, and integrated data make them smarter, faster, and more human. That’s the shift I’m leaning into—and the one customers feel immediately.
Over the past few years leading product at HighLevel, I’ve watched too many teams rush to demo flashy agents before they’ve built a reliable foundation. The metaphor I use in every AI roadmap review still hits home: “Think of AI readiness as a three-layer cake. Most companies are trying to build the fancy frosting (the agent interface) without bothering to bake the actual cake underneath.” If we want durable impact, we have to bake first, frost later.
When I design an AI Strategy, I anchor on three elements that map directly to that cake: a data and instrumentation foundation, a governance and risk layer, and finally the agent experience itself. This sequence isn’t theory—it’s how we de-risk delivery, accelerate product-market fit, and create competitive differentiation without compromising trust.
Layer 1 — Data and instrumentation: The base of the cake is clean, well-instrumented data flowing through a unified analytics platform. I start with a clear event schema, rigorous data quality checks, and tight CRM integration so we can connect outcomes to users, accounts, and journeys. Privacy-by-design is nonnegotiable: we minimize PII, define retention, and ensure consent flows are explicit. With this in place, gen ai features have the context they need—retrieval works, grounding holds, and feedback loops from production inform continuous improvement.
On top of that, I build measurement in from day one: activation, retention, task success, latency, and satisfaction. Every AI interaction is observable. We run A/B testing with a well-defined minimum detectable effect, pair quant with qualitative review, and feed human-in-the-loop judgments back into ranking and prompt libraries. This is how we avoid “demo-ware” and deliver real, repeatable value.
Layer 2 — Governance and risk: Before scaling, I formalize AI risk management and data governance. That includes model evaluation against safety and quality thresholds, red-teaming for jailbreaks, and threat detection and response for prompt injection and data exfiltration. We establish policy for model and provider selection, versioning, and rollback; we log prompts, responses, and decisions for auditability; and we define escalation paths when the system is unsure. These controls don’t slow us down—they create the confidence needed for faster iteration and board management alignment.
I also align legal, security, and product early on a taxonomy of risks—bias, hallucinations, privacy, IP leakage—so we can write tests and guardrails once and reuse them across features. The result is fewer surprises in customer pilots and a far smoother path through enterprise procurement.
Layer 3 — The agent experience: Only now do we invest in the frosting—the agent interface and workflows. Here I focus on clear jobs-to-be-done, crisp UX writing, and transparent system behavior. We design agentic AI flows that show reasoning steps when helpful, ask for clarification when confidence is low, and gracefully hand off to humans in customer support scenarios. Product tours, in-app guides, and tooltips reduce the learning curve and accelerate user activation.
Crucially, we measure the interface, not just the model. Agent Analytics tracks intents, tool use, fallbacks, and user corrections so we can tune prompts, tools, and policies. This closes the loop from experience back to data and governance, and it directly informs product roadmapping and sprint planning. When the cake is baked this way, go-to-market becomes easier: we can prove ROI with hard numbers, fine-tune pricing, and scale adoption with product-led growth tactics.
If your AI roadmap feels stuck, start with an honest readiness audit against these three elements. Shore up instrumentation and data pipelines, codify governance, then refine the agent interface with real user telemetry. Bake first. Frost last. That’s how we ship AI that customers trust—and keep winning after the first demo high fades.
Building AI agents looks deceptively simple right now. After leading multiple agentic AI initiatives, I’ve learned that the difference between a demo and a dependable product comes down to disciplined product discovery, ruthless scoping, and a clear AI Strategy that aligns with business outcomes. Here are four common misconceptions I correct early with stakeholders—and the practices I use to avoid expensive detours.
Misconception 1: “An LLM plus a few prompts is a production-ready agent.” In reality, production-grade agents require orchestration and rigor: tool-use and retrieval, memory design, state management, deterministic fallbacks, and continuous evaluation. I instrument Agent Analytics from day one to trace tool calls, latency, error codes, and cost per task; then I use A/B testing with a clear minimum detectable effect (MDE) to validate improvements before broad rollout. This is where product roadmapping and sprint planning matter—sequencing capabilities so we avoid building speculative features that don’t move outcomes.
Misconception 2: “More autonomy is always better.” The right autonomy level is contextual and risk-adjusted. For high-stakes workflows, I design for human-in-the-loop and role-based guardrails, grounded in privacy-by-design and data governance. Policies like least-privilege access, audit logs, and reversible actions reduce operational risk while still delivering leverage. In practice, this hybrid approach also controls cost: narrower scopes, clearer prompts, and bounded tool access reduce hallucination surface area and improve reliability—key to AI risk management.
Misconception 3: “If we build it, users will adopt it.” Adoption is earned with thoughtful onboarding and in-app guidance, not promised by a feature launch. I pair agent launches with targeted product tours, contextual tooltips, and progressive disclosure to drive user activation and product-led growth. Increase revenue, cut costs, and reduce risk with Pendo’s Software Experience Management platform. Optimize the entire software experience to drive adoption and improve engagement. Whether you use Pendo or a comparable solution, the principle stands: instrument the experience, run experiments, and iterate quickly based on evidence, not intuition.
Misconception 4: “Security, compliance, and governance can wait.” Deferring controls is a false economy. I embed AI risk management from day zero: prompt injection defenses, PII redaction, DLP, grounding and citation strategies, and threat detection and response. Clear data retention policies, vendor diligence, and model evaluation standards keep leadership, security, and legal aligned. This is the crux of building trust—and it’s far easier to design up front than to retrofit under pressure.
How I execute in practice: start with a tightly framed use case tied to a measurable outcome; define outcomes vs output OKRs; build a slim vertical slice to validate feasibility; instrument Agent Analytics from the first commit; ship behind feature flags; and operationalize learning loops across support, success, and GTM. The result is a durable path to product-market fit for agentic AI—one that compounds learning while minimizing blast radius.
The leaders who win with AI agents won’t be the ones who move fastest in a demo. They’ll be the ones who manage risk transparently, learn in public with their users, and turn continuous insight into competitive differentiation. If you’re planning your next agent milestone, align the roadmap to outcomes, treat governance as a feature, and make adoption your North Star.
I get asked this constantly by boards, CIOs, and product teams: WTF is MCP, and why does it matter for enterprise AI? Here’s my straightforward take from the trenches of rolling out agentic AI across complex, regulated environments—and why it changes how we design, govern, and scale autonomous capabilities.
“Model Control Protocol gives your AI agents arms and legs to go do stuff with your data.” That framing resonates because it’s both simple and accurate. MCP turns passive “chatbots” into active agents that can safely take action within defined guardrails.
In practice, MCP is the connective tissue between models and the tools, systems, and workflows we trust. It standardizes how agents request permissions, execute tasks, and report outcomes—so enterprises can move from demos to durable operations. The benefit isn’t just autonomy; it’s autonomy with accountability, aligned to our AI Strategy and data governance obligations.
When I pilot agentic AI in production, I start with a narrow scope: which systems the agent touches (for example, CRM integration via HubSpot), what actions it can take (read, write, or propose), and what evidence it must log (inputs, outputs, and approvals). That discipline keeps us compliant with privacy-by-design while unlocking real business impact.
Great MCP use cases emerge where read-write actions compress time-to-value. Think: pulling Amplitude analytics cohorts to personalize outreach, auto-generating Pendo in-app guides based on feature adoption, or triggering customer support workflows with predefined playbooks. Each action is observable, reversible, and measured—because in the enterprise, repeatability beats novelty.
From a product management leadership perspective, I treat MCP-enabled agents like any other product surface. We define clear outcomes, not outputs: success rate per task, mean time to resolution, quality score, and safety incidents. We validate uplift with A/B testing and a minimum detectable effect (MDE) before scaling. Then we feed results into an Agent Analytics dashboard, just as we would for product-led growth funnels.
Governance is where MCP earns trust. I enforce least privilege, time-boxed credentials, environment isolation, and tamper-evident audit logs. Every tool call is tied to a business purpose, owner, and SLA. We integrate with existing threat detection and response processes so cybersecurity teams see the same telemetry they’re used to—no shadow AI, no surprises.
There’s also an adoption playbook that works: start with a contained domain, ship a sandboxed agent, require human-in-the-loop approvals, then progressively relax controls as accuracy and alignment improve. Document the boundaries in plain language, and instrument everything from day one. This is how we de-risk AI risk management while accelerating impact.
The most exciting shift is cultural: teams move from asking “Can the model do this?” to “What outcomes should the agent own—and what guardrails make that safe?” That mindset unlocks empowered product teams, clearer ownership, and faster iteration. MCP is simply the operational backbone that lets those choices stick.
If you’re evaluating where to start, pick one workflow with high frequency, clear rules, and measurable outcomes. Wire it to MCP with tight scopes, ship it to a friendly cohort, and learn aggressively. Autonomy isn’t the end goal—reliable, governed value is. MCP just makes that scalable.
I spend a lot of time reviewing how customers move through our product and where their momentum stalls or accelerates. The tools you use to build and optimize software experiences are evolving. That simple truth reshapes our strategy every quarter, from the analytics we trust to the in-app touchpoints we design and the experiments we run to improve product-led growth.
When I say SXM, I’m talking about a comprehensive software experience management approach that unifies analytics, experimentation, in-app guides, messaging, and feedback loops. SXM vs. the rest is the real-world choice between an integrated platform and a patchwork of point solutions. I’m not married to one path; I’m obsessed with outcomes—speed to learning, lower friction for teams, and compounding retention gains.
The foundation is a unified analytics platform and a clean, consistent event schema. From there, I pair behavior analytics with in-app orchestration: tools like Amplitude analytics for deep behavioral insights and Pendo for targeted in-app guides, product tours, and contextual nudges. I instrument rigorous A/B testing with a clearly defined minimum detectable effect (MDE) and follow through with retention analysis to validate whether an uplift sticks beyond vanity metrics. Great UX writing and thoughtful tooltip design often make the difference between a nudge that converts and a prompt that gets ignored.
I choose between best-of-breed and platform consolidation using first principles decision making. If a point solution unlocks a capability that meaningfully advances our product discovery or activation work, I adopt it. If multiple tools converge on the same points of parity, I consolidate to streamline governance, reduce integration overhead, and accelerate delivery. The goal is not more software; it’s faster, clearer learning that informs product positioning and drives customer value.
AI now sits at the center of this stack. I apply gen ai and agentic AI to accelerate hypothesis generation, automate cohort detection, draft UX microcopy, and suggest next-best actions inside the product. That said, AI risk management, privacy-by-design, and data governance are non-negotiable. I won’t trade trust for tempo; we can have both by putting guardrails around training data, access controls, and evaluation criteria.
Operating rhythm matters as much as tooling. Product trios set outcomes vs output OKRs, then test and iterate—starting with onboarding, activation, and the moments that trigger value realization. We build in measurable in-app guides, run A/B testing with tight feedback cycles, and keep our go-to-market strategy aligned so every nudge, message, and feature release supports product-led growth.
My playbook is simple: clarify the outcomes, instrument the journey end-to-end, choose the smallest toolset that can answer the biggest questions, and learn faster than the market. Map critical paths, standardize taxonomy, and make experimentation a habit—not a project. Then double down where signal is strongest and retire anything that adds minimal lift to retention or expansion.
SXM isn’t a buzzword; it’s a disciplined way to build software that feels intuitive, responsive, and valuable from the first click. With the right blend of analytics, in-app guidance, experimentation, and AI—grounded in strong product management leadership—we can turn insights into momentum and momentum into durable growth.
“Do you know how your AI agents are performing?” I ask this question in every review because it exposes whether we’re managing by outcomes or by anecdotes. Too often, teams point to latency, token counts, or completion rates and call it a day—useful signals, but not the story.
In my role, shipping agentic AI into production means I need decision-quality evidence, not vibes. That starts with Agent Analytics built on a unified analytics platform and instrumentation that lets me trace behavior, quantify value, and manage risk. Below are the six questions I use to separate novelty from durable impact.
1) What outcome are we optimizing for—and how do we measure it? If we can’t map the agent’s work to outcomes vs output OKRs, we’re optimizing noise. I anchor on task success rate, time-to-resolution, containment rate (no human handoff), cost per successful outcome, and downstream business impact (retention, conversion, NPS/CSAT) to keep us honest.
2) Are the right guardrails in place for AI risk management and data governance? I expect documented policies for prompt injection defenses, PII redaction, access control, and auditability. Every tool call should be permissioned, every data boundary explicit, and every failure mode observable. If we can’t demonstrate compliance by design, we’re scaling risk instead of value.
3) Can I explain every decision the agent made? Agentic AI needs traceability: prompts, intermediate reasoning, tool calls, retrieved context, and final outputs. I route key events into Amplitude analytics so product, engineering, and risk can slice behavior end to end. If we can’t reconstruct the path to an answer, we can’t debug, improve, or trust it.
4) What is the true cost per successful outcome? Raw token spend is misleading. I model total cost of ownership across retries, tool usage, escalations, and human review time—then benchmark against a consumption SaaS pricing lens. If cost per resolution trends up as volume grows, we haven’t built a scalable system; we’ve built a demo.
5) How does the agent learn without breaking what already works? My bar is a disciplined experimentation loop: offline evals, online A/B testing with clear guardrails, and a rollback plan. We predefine a minimum threshold for improvement before rollout and track regressions by persona, task type, and channel so we can localize fixes quickly.
6) Where is this agent creating durable differentiation? I look for capabilities competitors can’t easily copy: unique data advantages, superior tool orchestration, or workflows that compound learning. If the edge is just a base model prompt, the moat will evaporate; if it’s embedded in product workflows and proprietary signals, we’re building advantage.
Answering these six questions turns agentic AI from a novelty into a managed system. With Agent Analytics feeding a unified analytics platform, we can tie behavior to business outcomes, enforce governance, and make portfolio trade-offs grounded in evidence. The result is a product management leadership motion that prioritizes real ROI over vanity metrics—and scales with confidence.
If you’re not satisfied with the answers today, start by instrumenting the journey end to end, aligning metrics to OKRs, and setting clear risk thresholds. The compounding effects show up quickly when every iteration is measurable, explainable, and accountable.
AI has fundamentally changed how I lead design and testing, not by replacing craft, but by compounding it. When my teams pair generative models with time‑tested product management practices, we move faster, learn sooner, and ship with more confidence—without compromising privacy-by-design or quality. The result is a tighter loop from product discovery to product-market fit lessons.
Learn how Pendo’s product design team is using genAI and traditional tools to speed up design and development.
That single line captures my own operating model: blend genAI with established toolchains to accelerate, not shortcut. In practice, I treat AI as a force multiplier for product trios—PM, design, and engineering—so empowered product teams can explore broader solution spaces while staying anchored to outcomes vs output OKRs.
In discovery, genAI helps me synthesize qualitative inputs at scale—interviews, support threads, and in-app behaviors—into testable opportunity statements. I triangulate those insights with a unified analytics platform and Amplitude analytics to spot friction, then use in-app guides and product tours to target learning, recruit the right cohorts, and validate problems before we overbuild.
For prototyping, gen ai for product prototyping is a game-changer. I generate multiple UX writing variants, microcopy, and flows in minutes, then narrow the set using heuristics and stakeholder feedback. Before any A/B testing, we precompute the minimum detectable effect (MDE) and sample size, making sure our experiments are powered to detect meaningful differences, not noise.
In testing, I combine classic A/B testing with AI-assisted analysis to surface patterns faster. GenAI drafts experiment summaries, flags anomalous segments, and proposes follow-up tests, while my team makes the final calls. We deploy targeted in-app guides to onboard users into trials, monitor adoption via event telemetry, and iterate quickly until the value proposition is unmistakable.
Execution depends on rigor and guardrails. We codify AI risk management and data governance policies, keep humans-in-the-loop for critical judgments, and log model prompts and outputs for auditability. This lets us move with speed and integrity, aligning stakeholder management, product roadmapping and sprint planning, and go-to-market strategy around measurable outcomes.
The payoff is material: shorter cycle times, clearer value narratives, and stronger product-led growth curves. By fusing genAI with traditional practices, we preserve the craft of design while scaling our capacity to learn. That’s how we differentiate—through faster insight generation, smarter testing, and experiences that feel unmistakably intuitive.
Leading product at HighLevel, I’m watching the convergence of SaaS + AI reshape how we build, price, and scale software. The winners will combine a sharp AI Strategy with disciplined product management leadership to ship real outcomes, not just demos. That’s why my team and I have been focused on giving you pragmatic ways to move fast without breaking trust.
Give your company an intelligent foundation for the SaaS + AI era with our Summer 2025 Release.
When I set priorities for this release, I optimized for three things: speed with quality, responsible AI, and measurable business impact. Practically, that means enabling agentic AI and gen ai workflows where they actually create leverage, unifying analytics so teams can make decisions from a single source of truth, and hardwiring data governance and privacy-by-design into every layer.
If you’re wondering how to keep up, here’s what’s working for us and our customers: tighten product roadmapping and sprint planning around clear outcomes, not outputs; align teams with simple, observable OKRs; and empower product trios to run lean product discovery loops. These practices reduce cycle time while raising confidence, especially when introducing AI into core experiences.
On the go-to-market side, I’m doubling down on product-led growth—shipping value into the product with in-app guides, thoughtful product tours, and frictionless onboarding. Pair that with rigorous retention analysis and A/B testing, and you’ll see which AI-powered moments actually move activation, adoption, and expansion. Don’t overlook the fundamentals either: smart SaaS pricing (including consumption models where it fits) can unlock the economics that sustain AI investments.
My goal is to give you a foundation that is both ambitious and accountable—a platform you can trust to scale responsibly while your teams iterate quickly. If you’re planning your 2H roadmap, this release is built to help you ship faster, de-risk AI, and create outsized customer value in the moments that matter most.
AI is moving faster than any product wave I’ve seen in my career, and that urgency demands rigor. At HighLevel, I anchor our AI Strategy around measurable outcomes, responsible delivery, and pragmatic execution—principles that a recent PendomoniumX NYC customer discussion reinforced for me.
“Three product leaders sat down with Pendo to discuss how they’re balancing AI investments, building their AI roadmap, and measuring success.”
When I decide what to fund, I start with outcomes vs output OKRs. If an initiative cannot tie to a defensible customer outcome—time-to-value reduction, revenue expansion, retention lift, or cost-to-serve efficiency—it doesn’t make the cut. From there, I pressure-test feasibility and risk through data governance and AI risk management lenses: model choice, training data readiness, privacy-by-design, security posture, and responsible use guardrails.
Building the roadmap is where discipline meets speed. I use empowered product teams—product trios across PM, design, and engineering—to run tight discovery sprints. We validate desirability and viability with gen ai for product prototyping, then graduate concepts into delivery using product roadmapping and sprint planning habits that prioritize smallest shippable value. I’ve found the try do consider framework helpful to stage bets from low-risk utilities to higher-impact, agentic AI workflows.
Measuring impact is nonnegotiable. I define success up front with a minimum detectable effect (MDE), then instrument adoption and behavioral change via Pendo and Amplitude analytics. A/B testing gives me causal confidence, while retention analysis tells me if AI features are durable value, not novelty. If we can’t attribute improvement to a metric that matters, we iterate or retire.
Governance is a product requirement, not an afterthought. We maintain data governance standards, threat detection and response controls, and clear model evaluation criteria before anything reaches customers. That operating model helps us move quickly without compromising trust—a cornerstone in any product-led growth motion.
For go-to-market and adoption, I rely on in-app guides, product tours, and contextual tooltips to shorten the learning curve. We measure feature discovery, task completion, and ongoing engagement to ensure the experience is intuitive. The goal is to make AI feel like a natural extension of the workflow, not a science project bolted onto the product.
My simple playbook: prioritize by customer outcomes and risk posture, build with validated learning and smallest shippable value, and measure with rigorous analytics and OKRs. Repeat that loop, and AI stops being a buzzword—it becomes a compounding advantage.
