Composio is a developer platform for building AI agents that can take actions across 1000+ external tools. It provides a unified way to handle integrations, authentication, and API interactions so developers can focus on building workflows instead of stitching together OAuth flows and SDKs for every tool.

That scale introduces real complexity. Each integration has its own APIs, auth patterns, and edge cases, which means even simple questions quickly turn into technical investigations. As Composio grew, their support team found themselves handling a constant stream of integration questions from developers trying to get things working. With Decimal powering both chat conversations and ticket investigations, developers can move fast with deep 40-turn technical discussions while the team focuses on the issues requiring specialized debugging.

The challenge

Composio serves thousands of developers building AI agents and automations with complex integrations. Each integration has unique authentication flows, API configurations, and implementation patterns that developers need to understand quickly to keep building.

The existing support workflow created a friction cycle that slowed everyone down:

• Developers asked technical questions about integrations

• Questions became tickets requiring formal responses

• Multi-day threads replaced what should have been quick technical conversations

• Developers waited for responses before continuing their builds

• Support team got buried in basic questions mixed with genuinely complex issues

This created unnecessary dependencies in the building process. Developers needed immediate technical context, not formal support ticket workflows.

The team had tried other solutions, but the quality wasn’t sufficient for technical conversations. Integration questions about OAuth configurations, API schemas, and error handling required understanding the actual implementation, not just generic documentation.

50% of the questions that we receive are just how-to’s. If you can get rid of that, it’s better for the user, better internally. It’s a win-win on both sides.

Abhishek Patil, Engineer

Building End-to-End Support

Rather than scaling the support team to handle growing volume, Composio built a complete support system using Decimal that handles everything from simple questions to complex investigations.

In January 2026, Composio launched an integrated approach powered by Decimal across their entire support workflow. The system was designed to handle the full spectrum of technical needs, from immediate chat responses to deep debugging investigations.

The architecture created seamless escalation paths:

Chat conversations: Developers get immediate answers to technical questions through real-time conversations with full code context. Deep 40-turn discussions replace what used to be multi-day ticket exchanges.

Automatic escalation: When issues require specialized investigation, they flow seamlessly to the support team with complete context and investigation tools already deployed.

Instead of separate systems for different types of questions, developers now experience continuous support that scales with the complexity of their needs.

The responses are really good. Really good. Decimal mainly refers to the code rather than just documentation. For technical questions, you want implementation details, not generic answers.

Abhishek Patil, Engineer

How Support Works Now

Today, every interaction follows a continuous support model that adapts to what developers need:

For technical questions (95% of interactions):

• Developers use chat directly on Composio’s platform

• Decimal analyzes questions against Composio’s codebase and API implementations

• Provides specific code examples, configuration guidance, and integration patterns

• Conversations continue as needed, often 40+ turns deep covering multiple technical aspects

• Developers build autonomously without waiting for formal responses

For complex investigations:

• Issues automatically escalate or developers explicitly request deeper help

• Ticket created with full conversation context preserved

• Decimal investigates using:

  • Datadog logs for system-level debugging

  • Instatus for incident correlation

  • Notion for specialized procedures and internal documentation

  • Complete codebase analysis for implementation-specific issues

• Support engineers review comprehensive findings and respond with full technical context

The support team is copying and pasting Decimal's responses directly in Plain. It's successfully identifying legitimate feature requests and providing responses that we can use as-is.

Rahul Tarak, Head of Product and Engineering

Deep technical conversations: Instead of creating tickets for integration questions, developers now have extended technical discussions that cover everything from initial setup to advanced configuration. A typical conversation might include OAuth implementation, error handling strategies, webhook configuration, and testing approaches - all resolved in a single continuous session.

The system ensures developers get the right level of support automatically, whether that’s immediate code examples or deep system investigation, without changing tools or losing context.

The Result

The transformation created measurable improvements across the entire support experience:

• Technical conversations handled through chat without creating tickets with 95% deflection rate

• Deep 40+ turn conversations replace multi-day ticket workflows

• Developers build autonomously with immediate access to technical context

• Support team focuses exclusively on complex issues requiring specialized debugging tools

During our recent hackathon, developers consistently highlighted the Decimal’s chat widget as something that allowed them to hack faster.

Sushmitha Mallesh, Developer Experience