How Kantata's PS team went from integration chaos to 8x delivery capacity

Accel-KKR backed Kantata powers professional services operations for companies like Box, Hitachi, and Toyota—resource planning, project delivery, time tracking, revenue recognition. When enterprises of this scale run on your platform, every new customer should be a milestone.

But for Kantata, every enterprise win triggered the same question: "How does this connect to our ERP?" And the answer—whether Sage Intacct, Oracle, NetSuite, or Dynamics—connecting to them was never simple.

Three platforms meant three times the complexity

Kantata had three existing options for integrations. They had used them all.

M-Bridge handled basics, but enterprise ERPs aren't basic. ERPs are systems built over decades, customized beyond recognition and governed by IT teams. These teams watched integration vendors promise seamless connections yet deliver endless timelines that stretched anywhere between 6–9 months. The moment a customer needed custom field mappings or non-standard workflows, M-Bridge hit a wall. Engineering tickets piled up. Timelines stretched.

Kantata Connect via Workato offered flexibility, but it lived as a separate platform. Consultants managed workflows in one system, troubleshot errors in another, and explained status to customers in a third. Enterprise IT teams wanted to know why their financial data was flowing through yet another vendor they hadn't vetted.

The Salesforce package worked for CRM sync and nothing else. But the moment another client mentioned NetSuite or Oracle, it was back to square one.

Three platforms. Three sets of credentials. Three places where something could break.

We had the team. We just didn't have enough people who knew how to do the work.

The deepest problem wasn't even tooling. It was the expertise required to use it.

Connecting Kantata to an enterprise ERP isn't just calling an API. Each system carries its own buried complexity: Sage Intacct with its dimension structures and AR billing flows, NetSuite behaving differently depending on whether the customer runs OneWorld, Oracle's revenue recognition breaking if you call endpoints out of sequence. Knowledge that takes months to learn and minutes to break.

This knowledge lived in a handful of senior consultants. One person could handle two, maybe three implementations at a time. Every enterprise deal competed for the same small pool. Every scope change became a project risk. The real cost wasn't time spent building—it was the implementations not happening and the junior team members who couldn't contribute.

A platform where AI agents do the work of integration architects

This is when Kantata brought in Refold AI.

Refold AI was built from the ground up for AI agents to do the work of senior integration consultants—not adapted for agents, but architected for them. Agents that understand how Sage Intacct structures dimensions. Agents that navigate NetSuite's SuiteScript layer and OneWorld configurations. Agents that sequence Oracle's API calls correctly without being taught. No drag-and-drop interfaces waiting for someone to manually figure out every mapping. Just AI that already knows how enterprise systems work.

Agents that understand how Sage Intacct structures dimensions and how billing flows through AR. Agents that know NetSuite's SuiteScript layer and can navigate OneWorld configurations. Agents that recognize Oracle's module dependencies and sequence API calls correctly without being taught.

One platform. Not three.

Refold replaced Kantata's three-platform stack because its AI does what none of them could—autonomously.

M-Bridge couldn't handle complex ERP logic. Workato could, but still required consultants to manually design workflows, select APIs, and configure field mappings. The Salesforce package only did CRM.

Refold's difference isn't where it runs—it's that the AI does the work. Describe the outcome, and the agent figures out the sequence and dependencies. The App Knowledge Graph finds the right endpoints across Sage Intacct, NetSuite, Oracle, Dynamics—without consultants digging through documentation. Agents map fields by meaning, not just matching names. No spreadsheets, no back-and-forth. Then it generates production-ready code with error handling, retry logic, and validation built in.

Workato gave Kantata flexibility. Refold gave them leverage. The difference is whether a human figures out the integration or an agent does.

A single example made the shift obvious

A consultant described what they needed: "When a project reaches 'Ready to Invoice,' create a draft invoice in Sage Intacct with the right project dimensions and billing terms."

The agent planned the workflow automatically:

• Sequenced the logic

  Understood that Intacct requires the customer record, project dimension, and contract terms to exist before an invoice can be created—and ordered the calls accordingly.

• Selected the right APIs

  Picked the exact SOAP endpoints for this customer's specific Intacct configuration.

• Mapped fields by meaning

  Kantata's "Billing Amount" to Intacct's "Transaction Amount," project codes to dimension values, payment terms to the right setup—no spreadsheets, no back-and-forth.

• Production-ready code

  Generated code with error handling, retry logic, and validation that catches mismatches before they hit the customer's financial system.

No spreadsheets passed between consultants and engineers. No two-week scoping exercises. The agent understood the systems and built the integration in an afternoon.

It's like giving your best consultant's knowledge to everyone on the team.

Within weeks, the math changed completely.

A single integration generalist built five production workflows in one week:

• Bidirectional sync between Kantata and Sage Intacct—project dimensions, billing milestones, and revenue schedules flowing both ways.

• Time entries and payment receipts syncing with NetSuite, respecting each customer's revenue recognition rules and closing the financial loop.

• Project cost data to Oracle Financials and resource assignments to Dynamics 365 for customers on those stacks.

These weren't templates for simple scenarios. They were deep, bidirectional integrations with business logic that used to require dedicated engineering sprints.

Scope changes stopped being project risks. When a customer asked mid-implementation to add Oracle revenue recognition sync, the consultant described the addition, the agent built the workflow, and it deployed by end of week. No escalations. No timeline impact.

We didn't add headcount. We removed the bottleneck.

By end of quarter, Kantata had transformed how enterprise implementations worked.

Consultants who used to escalate at the first mention of 'ERP' are now configuring workflows themselves. We went from two or three active implementations per person to six or nine. That's not incremental improvement—that's a different business.

The backlog cleared. Enterprise customers onboard faster. Senior consultants who spent their time on ERP plumbing now focus on strategic customer outcomes.

Today, Kantata handles enterprise ERP integrations at a pace that would have been unthinkable a year ago. No platform-hopping. No expertise bottlenecks. No scope changes derailing timelines.

Just agents that understand enterprise systems—and a team that finally has capacity to match their ambition.

The math that made the business case obvious

• 65–75% faster delivery

  6–9 week integrations now ship in 10–15 days.

• 8x consultant throughput

  2–3 concurrent implementations per person → 15–20, with zero additional headcount.

• 50% fewer escalations

  Automated validation and dependency-aware sequencing eliminated most mid-project rework.