AI Engineer

How Forward Deployed Engineering is done at Decagon — Sunny Rekhi

1804 summary words 8 min summary Watch video

Start with the signal

8 min read

Summary

At-a-Glance

  • Verdict: Skim
  • Core thesis: Decagon treats forward-deployed engineering as a product-scaling function: configure agents for individual enterprises, but systematically turn recurring customer-specific work into reusable, self-serve platform capabilities.
  • Why it matters: The talk offers a practical operating model for preventing enterprise AI deployments from becoming a growing inventory of brittle prompts, patches, and bespoke integrations.
  • Best use: Use it to pressure-test the boundary between implementation, solutions engineering, product engineering, and customer success in an agent business—especially the mechanisms for converting field learning into product leverage.

Executive Summary

Sunny Rekhi describes Decagon's forward-deployed engineering (FDE) motion for enterprise AI customer-service agents. The company initially lands by automating complex inbound support across channels, then expands into proactive, revenue-producing workflows once its agent is integrated with customer systems. His central operating principle is that every deployment should make future deployments faster and more capable.

Decagon sees two forms of FDE: configuring the agent's behavior for a particular customer—tone, intents, escalation rules, and backend actions—and translating enterprise requests into scalable product features. Rekhi argues these should not be organizationally separated from product engineering: customer pain discovered in the field is frequently the product roadmap, so FDE and product should share a quality bar, reporting structure, and often teams.

As Decagon grew from roughly 50 to 500 people in a year, it split the original generalist agent-software-engineer role into agent builders, who configure agents primarily through the UI and understand model behavior, and agent software engineers, who productize needs that exceed the UI. The key discipline is resisting the now-easy option of AI-generated, customer-specific code or prompt patches when it would create a brittle black box.

The practical playbook is to define written success criteria at deal inception, deploy a narrow high-value use case quickly, use historical support data to advise customers on the highest-ROI automation sequence, staff deployments with vertical expertise, and upstream every recurring manual task into product or self-service. The presentation is high-signal for the operating philosophy, though it is repetitive and light on implementation mechanics, metrics, or concrete organizational interfaces.

Key Takeaways

  • Claim: Forward-deployed engineering should be treated as product engineering rather than as a separate custom-services layer. | Evidence: Rekhi says Decagon uses the same bar, reporting structure, and often the same teams for FDE and product engineering because a pain point voiced by a Fortune 20 customer is often a feature that must be built and prioritized. | Implication: Ken should design field-facing agent teams with direct product ownership and clear routes to platformization, rather than measuring them only on deployment delivery. | Caveat: The talk asserts this organizational model but does not explain how Decagon resolves conflicts between urgent account demands and broader roadmap priorities.
  • Claim: The scarce FDE skill in an AI-coding era is architectural restraint, not the ability to rapidly produce a bespoke fix. | Evidence: Rekhi warns against responding to a major customer's urgent request by using Codex or Claude Code to create a one-off implementation; Decagon wants agents to be customer-owned, not opaque collections of prompts and patches. | Implication: Adopt a review threshold for customer-specific agent logic: require an explicit decision on whether each customization is temporary, reusable, configurable, or eligible for self-service. | Caveat: Some one-off work may still be necessary to establish early value; the speaker's point is that it must not become the enduring architecture.
  • Claim: Decagon scaled by splitting a formerly generalist deployment role into agent builders and agent software engineers. | Evidence: At roughly 50 employees, agent software engineers handled agent configuration, customer integrations, and platform work. At roughly 500 employees, Decagon created agent builders who work mainly in the UI and specialize in model/application behavior, while agent software engineers handle product and platform needs surfaced by enterprises. | Implication: Separate high-throughput configuration work from reusable engineering work only once volume and complexity justify specialization; preserve a tight escalation loop from builder to product/platform engineering. | Caveat: No staffing ratios, handoff rules, or criteria for determining when work must leave the UI are provided.
  • Claim: Success criteria must be narrowed and documented before enterprise implementation begins. | Evidence: Decagon now scopes the customer's pain point, desired outcome, target metrics, and initial support channel—phone, email, text, WhatsApp, and so on—in the earliest conversations and seeks to get that definition in writing. | Implication: For agent deployments, establish a written launch contract covering the first workflow, channel, success metric, escalation boundary, and backend actions before building; do not let fast AI coding substitute for requirements work. | Caveat: The presentation does not supply example metrics, baselines, or an acceptance-test format.
  • Claim: A deployment should prove value through a narrow wedge quickly, then expand into broader support and revenue workflows. | Evidence: Decagon says enterprise customers often request the 'whole kitchen sink,' but it seeks to demonstrate value without a multi-month time-to-value. Hertz reportedly began with complex inbound-support automation and later expanded to proactive outreach around vehicle lease renewal or extension using Decagon's existing backend integrations. | Implication: Prioritize an initial agent workflow with clear, rapid economic proof, while architecting integrations and permissions so the same installed base can support later proactive and revenue-generating use cases. | Caveat: The Hertz example is illustrative rather than quantified; no ROI, conversion, or deployment-duration figures are given.
  • Claim: The FDE team should act as an ROI advisor because it sees patterns across customers, not merely execute the customer's initial request. | Evidence: Decagon ingests a customer's historical support data and recommends which automations to prioritize for the highest ROI; Rekhi says this sometimes differs from the workflow the customer originally requested. | Implication: Build an intake and analysis layer that ranks candidate workflows by volume, cost, resolution potential, risk, and commercial upside, then use it to guide customer sequencing. | Caveat: This advisory posture depends on access to sufficiently complete historical data and on credible analysis; the speaker does not describe governance, evaluation, or data-quality safeguards.
  • Claim: The core compounding loop is to turn manual or repeated custom work into configurable and eventually self-serve product capability. | Evidence: Decagon initially built custom CRM integrations repeatedly, then, after approximately the 25th such integration, converted the work into a self-serve capability usable by customers or the agent-builder team. Rekhi summarizes the operating mantra as 'custom becomes self-serve.' | Implication: Instrument manual deployment tasks and recurring requests, then maintain a productization backlog weighted by frequency, implementation effort, deployment delay, and potential for safe customer configuration. | Caveat: Not all repeated requests are necessarily suitable for self-service; the talk offers no prioritization rubric beyond recurrence and scaling value.

Detailed Brief

Enterprise deployment knowledge should compound by vertical

  • Claims: Deployment effectiveness improves when teams repeatedly serve the same industry rather than rotating generalists across unrelated accounts.; Vertical specialization creates both customer credibility and reusable intuition about workflows, language, compliance context, and definitions of success.
  • Evidence: Rekhi's example is staffing a core group with experience across financial-services customers A, B, and C when financial-services customer D is acquired.; He argues this enables teams to speak the customer's language, ramp faster, and carry forward agent-building patterns.
  • Caveats: The talk does not address the trade-off between vertical specialization and cross-industry transfer of product patterns.; No formal knowledge-management process, reusable template format, or ownership model is described.
  • Implications: Treat vertical playbooks as product assets: encode known intents, system integrations, guardrails, evaluation cases, and ROI archetypes so expertise is not retained only in individual field staff.; Monitor whether account teams are re-solving prior vertical problems; repeated rediscovery is a signal that the feedback loop into platform and documentation is failing.

Decagon's commercial expansion model

  • Claims: Decagon positions customer-service automation as the entry point, with deeper integrations creating an opportunity to expand into proactive customer communications and revenue workflows.; The company attributes its momentum to fast responsiveness, trusted advisory behavior, and productization of field work.
  • Evidence: Decagon describes itself as a multilingual, omnichannel, 24/7 AI customer-service agent.; The Hertz example illustrates expansion from inbound support deflection into lease renewal or extension outreach.; Rekhi says the company grew from 50 to 500 people over about one year.
  • Caveats: The claims are company self-description and do not include independently verifiable operating or commercial performance metrics.; Revenue-workflow expansion introduces different approval, compliance, customer-experience, and measurement requirements than support deflection.
  • Implications: For agent businesses, assess the initial workflow not only for immediate ROI but also for whether it earns the integrations, trust, and permissions required for higher-value expansion paths.; Keep support automation and outbound/revenue agent governance distinct rather than assuming a successful support deployment automatically validates proactive engagement.

Notable Concepts & Terms

  • Forward-deployed engineering (FDE): A field-facing engineering function that both implements customer solutions and converts repeated enterprise needs into product capabilities.
  • Agent builder: Decagon's specialized role for configuring agent behavior, primarily through the product UI, using practical intuition about the models powering the platform.
  • Agent software engineer: Decagon's specialized engineering role for handling needs beyond configuration and incorporating enterprise requirements into the scalable product.
  • Custom becomes self-serve: The operating mantra that recurring manual implementation work should become configurable product functionality available to customers or non-engineering deployment staff.
  • Customer-owned agent: An agent implementation that remains understandable and configurable by the customer, rather than becoming an opaque and brittle accumulation of custom prompts and patches.
  • Land and expand: Decagon's commercial pattern of beginning with inbound support automation and expanding into additional support channels or proactive revenue workflows after integration.
  • Time to prove value: The time needed for an enterprise deployment to demonstrate measurable benefit; Decagon seeks to minimize it by starting with a focused initial scope.

Operator Notes / Why Ken Should Care

  • Create a deployment-to-product escalation rubric with four outcomes: retain as temporary bespoke work, make configurable, build a reusable platform primitive, or expose as safe self-service.
  • Require every enterprise agent engagement to have a written initial success contract before implementation: target channel, bounded intent set, economic metric, baseline, handoff conditions, required integrations, and launch acceptance test.
  • Instrument implementation work at the task level and review recurring manual steps monthly; use recurrence and deployment drag to trigger productization decisions before custom work becomes entrenched.
  • Build a workflow-prioritization analysis from historical interaction data so the team can recommend the highest-leverage automation sequence instead of accepting customer-requested scope uncritically.
  • Separate governance for inbound support automation from governance for proactive outbound or revenue actions, particularly around permissions, brand risk, compliance, and measurement.

Source/Metadata

  • Title: How Forward Deployed Engineering is done at Decagon — Sunny Rekhi
  • Transcript words: 4968
  • Duration seconds: 1088
  • Timestamp note: No usable timestamps or chapters were present in the provided transcript. The latter portion substantially repeats earlier material.
Full transcript 3041 words · 22 min read
0:04

How many guys? Can you hear me just fine? All good? Okay, awesome.

0:15

Just so I can contextualize this talk a little bit, can I get a show of hands of who here is an engineer or is in a forward-deployed motion at all? Okay, okay, so I'm a minority. Okay, awesome. Sounds good. So yes, I'm Sonny. I'm the CTO of Forward-Deployed Engineering here at Decagon. And today I'll talk about what it is that we do, why we have a forward-deployed motion, how it has changed over time as we've gone from 50 people to 500 people over the course of a year, how it changes if you're working with a Fortune 20 versus a more mid-market brand. Thank you all for coming. I hope it's useful. And yeah, let's get started.

0:48

So, great. Okay, just to give context on what Decagon is: For those of you unfamiliar, Decagon is a 24-7 AI customer service agent. We've all had the experience of calling your favorite brand and being told to press one for billing, press two for membership options, etc. Or you email your brand because you need urgent support and you hear back in two or three business days. Decagon replaces all of that. Instead, you pick up and call your brand of choice and you get a human-like agent who is helping you. You email in, you get a human-like reply right away. So that's what Decagon does in a nutshell. Multilingual, omnichannel, etc.

1:21

And then importantly, and again, I say this to help contextualize what our forward-deployed motion does, we land in our customers to help them with the kinds of complex support workflows that today have to go to humans. But once we are there and our agent is learning about the customers and has a relationship with the customers, then we also work with our customers to figure out, hey, how can we actually make you more money?

1:27

So one example, you'll see this at the bottom of the slide here, but Hertz, we're all familiar with. Hertz came to us because they had these complex inbound support workflows that needed to be offloaded to an agent. But once we were there, it turns out, hey, we already have these integrations to your back-end systems. What other communications are you doing with customers? And one that Decagon now does for them is to reach out proactively to a customer when it's time to renew their car lease or extend it or whatever. And they can do that from within Decagon.

1:34

So it is: we typically land and help them deflect these inbound support cases, and then we expand into how do we make you more money. Now we work cross-vertical. We also have really large enterprises, more mid-market brands. These are a subset of what I was approved to talk about. There were way more I wanted to add in there, but our marketing head got mad at me. We have, at the top left, our financial institutions. At the bottom right, we have your favorite tech brand. And this is relevant because, as I'll talk about briefly, the kind of forward deployment you have to do is vastly different based on both the size of the enterprise and also the vertical.

1:47

Okay, so I imagine this is the case for a lot of agentic companies. But Decagon has effectively two kinds of forward-appointed engineering.

1:56

Number one is taking that AI customer service agentic brain and making it work for your enterprise. The same way that you train a human, you give it instructions on what to do when a user asks X, how you respond back to it, what sort of brand tonality you have, what actions do you take on behalf of the user. All of this configuring of that agent brain is one form of our forward deployment motion, where we work with the customer, we figure out what does success look like for you, how do you want the agent to speak, what sort of user intents do you actually want the agent to hand off to a human instead.

2:05

That's the left half of this diagram. And we have a team, which I'll talk about briefly, who is really good at configuring the agent. Largely, this can also happen within the UI. And then on the right side, the previous speaker alluded to this as well. Forward deployment, forward-appointed engineers are the front line for customer product asks. And it is their job to figure out, hey, enterprise A made this ask. I know in two weeks, enterprise B is also going to have the same ask. And this happens with stunning regularity. So I want to make sure when I solve enterprise A's problem, I'm solving it for B, C, D, and E before they've even had a chance to express it.

2:14

So those are two kinds of forward-appointed engineering that we have internally: configuring the agent and then making sure all the problems that you interact with in the enterprise, that come up in the context of the conversation, also get brought back into the product. Which brings me to a really important point. In fact, it's so important I wish I had a slide for it. At Decagon, forward-appointed engineering is identical to product engineering. It's the same bar, it's the same reporting structure, often the same team. Because the delineation between what is historically forward-appointment versus product engineering is super, super blurred now.

2:31

When I'm speaking with a Fortune 20 and they express a pain point, that is often a product feature that needs to get built and prioritized. So that line between I'm a forward-appointed person and I'm a person who works in the product is gone. It's the same person, and that's represented in our org chart. So, early on, Decagon is an example of canonical hyper-growth. A year ago we were at 50 people, now we're at 500, and the scale is not slowing down. So actually, shameless plug: if you are interested in a new role, sunny@decagon.ai is my email. Please let me know. I'll make sure your resume/profile gets to the right people. Anyway, back to the talk.

2:49

So historically we had agent software engineers, and they did it all. They did that configuring of that agent brain, sitting side by side with our customer. This is, again, things like what is the tonality of the agent, what sort of voice do you want it to have, both literally the voice but also the way it speaks. How do I integrate it into your back-end system so that it can take action on behalf of the users? This can be something simple, like I want to reset my password, so the agent needs to have back-end access into your authentication system. And it can be something far more complex than that.

2:57

And they also did some of that platform work, like customer A has this feature request, and then building that back into the product. Now that we're 500 people, we start thinking a lot more about how do we design the Decagon system so that it can scale. And effectively, we broke apart this agent software engineering role into two specialized lanes.

3:03

One is the agent builder, and these are Decagon pros. They have a lot of intuition for the various models that power our platform. How do you make them work for the use case that the enterprise requires? Largely living within the UI to the extent possible, flagging when things need to go off-UI, and how do we bring that into the product. And then secondly, we have agent software engineers. And again, these are the front line when the enterprise makes product requests, making sure that gets incorporated back into the product.

3:10

And this is, I think, a super, super important insight, which is there is routinely this temptation of, okay, customer A made this request, and they're so important to us, and they want it done ASAP, and maybe I'll just go prompt Codex and Cloud Code to do it for me. But the scarce skill, now that AI coding is so good, is actually exercising restraint and really thinking about how is this going to scale to future customers. And part of this is our ethos. We build agents to be owned by the customer, and so if it turns into a black box of prompts and patches, then that's not good for us or them. It's far too brittle.

3:33

But also, when you're a forward-deployed person, this is incumbent upon you: to be exercising this restraint of, let me not do the easy one-off thing, but rather make sure whatever I am building is architected in a way that future customers benefit from. So this will come up in the remainder of my 10 minutes here, which is always thinking about how do I make this one ask benefit the remainder of the customers. So I put this slide here not to toot our own horn, but to actually talk about what it looks like to achieve success.

3:50

In our case, we've learned early on, when you're scoping the deal, literally in the very first conversations, you want to figure out ahead of time what does success look like for the customer, and really narrow that out, ideally getting it in writing so that there is no miscommunication along the way. And when I say what does success look like, I mean what are the metrics you're trying to hit, what sort of channel that you want support on. Maybe that's a phone call, maybe that's email, maybe that's text, maybe it's WhatsApp, whatever. But really narrowing what is your pain point, what is the ideal outcome you want, and then we can race to go build that out.

4:20

But I think, again, back to lessons for forward-deployed folks, especially when you're dealing with a large company, there's this temptation to just get started. And this is partly a reflection of how AI coding has changed engineering generally, but now there's a lot of effort that has to go up front in requirements gathering, making sure you're aligned on what actually has to get built before going to do it. This has been a really good learning for us.

4:22

So we try now, given that we have a ton of customers across various verticals, we have found it's really helpful to have industry experts that get staffed to the same kind of deal. So if I'm working on financial service A, B, and C, when financial service company D comes around, ideally I have a core group of folks who have experience with those customers working with this new logo. And the idea here is a lot of that knowledge compounds. You can speak in the lingo of this customer, and therefore there's a lot more credibility there. There's a much faster ramp-up, and a lot of the agent building, the way you think about success, carries over.

4:30

So this has been very helpful for us, and ultimately it's all about making every deployment faster than the last one. So I mentioned earlier that as forward-deployed, and by the way, I say forward-deployed engineering, but really it's all forms of forward deployment, one of the big things you have to do is to always think about how do I solve this customer problem in a way that extends to other customers. The other thing that I think is always helpful to keep top of mind is how do I make it so that I am empowering the rest of the business to solve this problem? And this is specifically if you're in engineering.

4:48

So, for example, Decagon's ethos is you should be able to configure this agent completely via natural language. And so if you ever have an engineer needing to do something, that needs to get upstreamed back into the product. And so this is a funnel that we have of: look, forward-deployed engineering, they're the front line for customer asks. But really it should get scaled across the business.

4:54

And one example of this, and I mention it later as well, is let's take an integration. Let's say Decagon needs to integrate into some CRM. Early on in our history, we were actually just building custom integrations time and time again. And then we thought enough is enough after the 25th one. We were like, I don't know how many more are coming up, so let's just build it in a self-serve way. And now what took an engineer custom code writing can now be self-served by the customer or built by our agent building team. So it's all about how do you scale the work that you're doing.

5:15

Also very relevant, depending on the kind of forward deployment work you do, is especially in the enterprise, wanting to prove value as fast as possible. For those of you who work especially in the Fortune 500, you're going to get hit with the entire, what's the expression, kitchen sink or the entire kitchen, something like this. But the idea is how do you prove value as fast as possible?

5:19

So in our case, Decagon can become arbitrarily complex. You can support all sorts of channels, all sorts of very complex user intents. We try to figure out how do we demonstrate value ASAP and not have a multi-month time to prove value. And once we're there and we're adding value, then we expand, right? Because ultimately all of our customers are a multi-year partnership. And so we want to make sure we're helping you across your entire support flow and your revenue-generating workflows. But it's important as a forward-deployed person to figure out how do I prove value right away and build your motion around that.

5:34

So customers will often come to folks and say, I want you to do X, Y, Z. And often they're right. But I think as a forward-deployed engineer, or forward-deployed person of any sort, you should treat yourself as an advisor rather than just an executor. You're both. You're also on the front line of, hey, how do I make AI work for the enterprises? And you have so much knowledge because you're seeing it repeated across every single customer.

5:50

And so what we do at Decagon is we actually ingest your historical support data and we tell customers that, hey, if you automate this first or this first, this is where actually you'll see the highest ROI. And sometimes that's not actually what the customer had reached out about.

5:56

And I imagine there are analogs to this across all sorts of verticals. But it's important to keep in mind that your job isn't just executor. It is, of course, to be an executor. But it is also to be an advisor, and to not underrate the fact that you have this domain expertise by being forward-deployed across many companies, so that you have this knowledge base that's really valuable for the customer to tap into.

6:05

Every time at Decagon someone has to do something manually, we try to make sure it gets upstreamed back into the product. So I mentioned the integration earlier. But this is, I think, a good mental model for folks to have if you're on the front lines: how do we smooth out that path? Custom becomes self-serve. Custom becomes self-serve. This has become a guiding ethos for us, and I suspect it is the case across every kind of forward-deployed motion. So I'd encourage everyone in this audience to keep this top of mind. Okay, I'm doing this one-off thing. Presumably other people in the company also are. Bring it back into the product. Okay.

6:27

So Decagon is really interesting in that it was started by, I think now they're in their early 30s, but I think at the time they were in their late 20s. So what did we do right to deserve the place that we have? I think one is we're known in the industry to move really, really fast on customer asks. And part of this is just that it's a very hard-working group of folks. So that's a big reason that we got here, that we just move really fast deal by deal.

6:33

I think number two, we've earned trust with customers that we are advisors, not just executors. So we'll be able to tell you, based on what we're seeing across all the customers, based on the data you give us, what is going to be the highest ROI for you. And then number three, we've been really good at making sure we productize custom work. But the way we think about this has changed a lot in the last year. Because, again, a year ago we were 50 people, could all fit on a lengthy lunch table, and now we're 500. So now we think a lot about designing the system.

6:53

So every time, now we're very rigorous about sharing knowledge across deployments, but making sure the people in the field feed information back to the platform. Making sure the agent compounds every single time it interfaces with the customer. So if the agent interfaces with customer A, you improve that for customer B. And it's all about taking knowledge from the field and bringing it back into the product. And so just to wrap up here, a few of the themes:

7:04

Number one, obviously you have to make sure you configure that agent, do whatever the customer wants. But number two, make sure that it gets fed back into the product. And three, mine that funnel that I mentioned earlier. You're in the field, but you want to make sure it scales and make sure it improves every future customer interaction. Again, my email is sunny@decagon.ai. I'll also be out here if folks have questions. Thank you for coming to talk, and I hope this is helpful. And effectively, we broke apart this agent software engineering role into two specialized lanes. One is the agent builder, and these are like decagon pros.

7:33

They have a lot of intuition for the various models that power our platform. How do you make them work for the use case that the enterprise requires? Largely living within the UI to the extent possible, flagging when things need to go off UI and how do we bring that into the product. And then secondly, we have agent software engineers. And again, these are the front-line enterprise makes product requests, making sure that gets incorporated back into the product.

7:59

And this is, I think, like a super, super important insight, which is there is routinely this temptation of, okay, customer A made this request, and they're so important to us, and they want it done ASAP, and maybe I'll just go prompt Codex and Cloud Code to just do it for me. But the scarce skill, now that AI coding is so good, the scarce skill is actually exercising restraint and really thinking about how is this going to scale to sort of future customers. And part of this is our ethos. Like, we build agents to be owned by the customer, and so if it turns into a black box of, like, prompts and patches, then that's not good for us or them. It's far too brittle.

8:41

But also, when you're a forward deployed person, this is kind of, this is incumbent upon you to be exercising this restraint of, like, let me not do the easy one-off thing, but rather make sure whatever I am building is architected in a way that future customers benefit from. So this will come up in the remainder of my 10 minutes here, which is always thinking about how do I make this one ask benefit the remainder of the customers.

9:11

So I put this slide here not to sort of toot our own horn, but to actually talk about what it looks like to achieve success. And in our case, we've learned, like, early on when you're scoping the deal, like, literally in the very first conversations, you want to figure out ahead of time what does success look like for the customer? And really narrowing that out, ideally getting it in writing so that there is, like, no miscommunication along the way. Like, and when I say what does success look like, I mean what are the metrics you're trying to hit, what sort of channel that you want support on.

9:45

Maybe that's a phone call, maybe that's email, maybe that's text, maybe it's WhatsApp, whatever. But really narrowing, like, what is your pain point, what is the ideal outcome you want, and then we can race to go build that out. But I think, again, back to sort of lessons for forward-deployed folks, there, especially when you're dealing with a large company, there's this temptation to just get started. And this is partly a reflection of how AI coding has changed engineering generally, but now there's a lot of effort that has to go up front in requirements gathering, making sure you're aligned on what actually has to get built before going to do it.

10:22

This has been a really good learning for us. So we try now, given that we have, like, a ton of customers across various verticals, we have found it's really helpful to have industry experts that get staffed to the same kind of deal. So if I'm working on financial service A, B, and C, when financial service D company comes around, ideally I have a core group of folks who have experience with those customers working with this new logo. And the idea here is, like, a lot of that knowledge compounds. Like, A, you can speak in the lingo of this customer, and therefore there's a lot more credibility there.

10:58

There's a lot more, there's a much faster ramp up, and a lot of the agent building, sort of the way you think about success carries over. So this has been very helpful for us, and ultimately it's all about, you know, making every deployment faster than the last one.

11:18

So I mentioned earlier that as a forward deployed, and by the way, I say forward deployed engineering, but really it's just, like, all forms of forward deployment. I mentioned earlier that one of the big things you have to do is to always think about how do I solve this customer problem in a way that extends to other customers. The other thing that I think is always helpful to keep top of mind is how do I make it so that I am empowering the rest of the business to solve this problem? And this is specifically if you're in engineering. So, for example, Decagon's ethos is you should be able to configure this agent completely via natural language.

11:54

And so if you ever have an engineer needing to do something, that needs to get upstreamed back into the product. And so this is sort of a funnel that we have of, like, look, forward deployed engineering, they're the front line for customer asks. But really it should get sort of scaled across the business. And one example of this, and I mentioned it later as well, is, like, let's take an integration. Let's say Decagon needs to integrate into, like, some CRM. Early on in our history, we were actually just, like, building custom integrations time and time again. And then we thought enough is enough after, like, the 25th one.

12:25

We were like, I don't know how many more are coming up. So let's just, like, build it a self-serve way. And now what took an engineer custom code writing can now be self-served by the customer or built by our agent building team. So it's all about how do you scale the work that you're doing.

12:42

Also very relevant, depending on the kind of forward deployment work you do, is, especially in the enterprise, wanting to prove value as fast as possible. For those of you who work, especially in the Fortune 500, you're going to get hit with the entire, what's the expression, kitchen sink or the entire kitchen, something like this. But the idea is how do you prove value as fast as possible? So in our case, Decagon can become arbitrarily complex. You can support all sorts of channels, all sorts of very complex user intents. We try to figure out how do we demonstrate value ASAP and not have, like, a multi-month deal. Or, sorry, multi-month time to prove value.

13:21

And once we're there and we're adding value, then we expand, right? Because ultimately all of our customers are a multi-year partnership. And so we want to make sure we're helping you across your entire support flow and your revenue-generating workflows. But it's important as a forward-deployed person to figure out how do I prove value right away and build your motion around that.

13:46

So customers will often come to folks and say, I want you to do X, Y, Z. And often they're right. But I think as a forward-deployed engineer or forward-deployed person of any sort, you should treat yourself as an advisor rather than just an executor, right? You're both. So you're also on the front line of, hey, how do I make AI work for the enterprises? And you have so much knowledge because you're seeing it repeated across every single customer. And so what we do at Decagon is we actually ingest your historical support data and we tell customers that, hey, like, if you automate this first or this first, this is where actually you'll see the highest ROI.

14:32

And sometimes that's not actually what the customer had reached out about. And I imagine there's analogs to this across all sorts of verticals. But it's important to keep in mind that your job isn't just an executor. It is, of course, to be an executor. But it is also to be an advisor. And to not underrate the fact that you have this domain expertise by being forward-deployed across many companies so that you have this knowledge base that's really valuable for the customer to tap into.

15:03

Every time at Decagon someone has to do something manually, we try to make sure it gets upstream back into the product. So I mentioned the integration earlier. But this is, I think, a good mental model for folks to have if you're on the front lines. How do we smoothen out that path? Custom becomes self-serve. Custom becomes self-serve. This has become, like, a guiding ethos for us. And I suspect it is the case across every kind of forward-deployed motion. So I'd encourage everyone in this audience to keep this top of mind. Like, okay, I'm doing this one-off thing. Presumably other people in the company also are. Bring it back into the product.

15:43

Okay. So Decagon is really interesting in that it was started by, I think now they're in their early 30s, but I think at the time they're in their late 20s. And so what did we do right to sort of deserve the place that we have? And I think one is we're known in the industry to move really, really fast on customer asks. And part of this is just like it's a very hard-working group of folks.

16:10

So that's, like, a big reason that we got here is that we just move really fast deal by deal. I think number two, we've earned trust with customers that we are advisors, not just executors. So we'll be able to tell you, based on what we're seeing across all the customers, based on the data you give us, what is going to be the highest ROI for you. And then number three, we've been really good at making sure we productize custom work. But the way we think about this has changed a lot in the last year. Because, again, a year ago we were 50 people. Could all fit on, you know, a lengthy lunch table. And now we're 500. So now we think a lot about designing the system.

16:51

So every time, now we're very rigorous about sharing knowledge across deployments. But making sure you extend the field, the people in the field, feed information back to the platform. Making sure the agent compounds every single time it interfaces with the customer. So if the agent interfaces with customer A, you improve that for customer B. And it's all about sort of taking knowledge from the field and bringing it back into the product. And so just to wrap up here, sort of a few of the themes. Number one, obviously you have to make sure you configure that agent, do whatever the customer wants. But number two, make sure that it gets fed back into the product.

17:33

And three, mine that funnel that I mentioned earlier. You're on the forward, you're on the field, but you want to make sure it scales and make sure it improves every future customer interaction. Again, my email is sunny at decagon.ai. I'll also be out here if folks have questions. Thank you for coming to talk and I hope this is helpful.

Reading tools

Type to find a passage

Appearance
Ask this transcript

Add a note