How LogicGate accelerated revenue growth by 35%

Turning company rules into running software

LogicGate is a no-code platform that helps companies design and manage their GRC programs. Their customers range from upper mid-market companies to large enterprises with complex compliance and risk requirements, and each client's version of LogicGate is tailored to its specific workflows. One firm's vendor risk program may look nothing like its peer's, and LogicGate is built to make that possible.

Governance, Risk, and Compliance (GRC) software is the category of tools that help a company keep track of its own rules and prove it's following them. The three letters stand for:

• Governance: employees confirming they've gone through harassment training, read written policies, and know their expense approval process.
• Risk: a central register of things that could go wrong (a key vendor could get hacked, ransomware could strike, a currency could swing rapidly) each scored by likelihood and impact, and tracked over time.
• Compliance: mapping the company's actual "controls" to the alphabet of external frameworks - SOC 2, ISO 27001, HIPAA, GDPR, PCI-DSS, SOX - and collecting evidence that those controls are working.

The magic LogicGate sells is that you describe your process once, and the software runs it forever after, constantly adjusting to ever-changing risks and frameworks. 

Take a vendor approval workflow. Someone fills out a form requesting a new vendor. Based on what they enter, the request routes itself: to the CISO for a security review, to the vendor to provide additional details, to the budgeting office for sign-off. Each of them gets their own form, and only when all three have finished does the request move to a final approver. The software knows who's next at every step so nobody has to manually chase their teammates down.

The hard part is building that workflow in the first place.

The implementation team

Risk Cloud is LogicGate’s deeply configurable software platform designed to adapt to any enterprise workflows. To help customers quickly tailor the system to their specific needs, LogicGate offers a team of expert implementers that can guide setup.

Every company works differently, so the workflows built with Risk Cloud can be unique to that company. Who answers which questions, which fields are dependent on other fields, what an auditor might want to see two years from now are all things that have to be encoded. So a single workflow often runs to thousands of fields.

The implementers are the experts who know exactly how to build those thousands of fields. These specialists serve as trusted guides who partner with customers to speed up setup, share best practices, and help teams master Risk Cloud. They sit down with a new customer, learn how their processes work, draft applications, bring it back to a client for signoff, and iterate until the customer is happy. They’ve done this many times before, so they know which questions to ask, and where customers typically get hung up. 

Given the complexity involved, this process could take weeks to sometimes months for LogicGate’s most mature customers.

The constraint

LogicGate was selling well, and every new customer wanted the implementation team’s expertise applied to their specific workflows. But great implementers are rare: the job combines GRC expertise with deep platform knowledge that takes years to build.

So the implementation team grew linearly while the customer list compounded. Demand for the team’s time grew faster than hiring could keep up with.

LogicGate saw this as the highest-leverage place to start its AI transformation, and brought in Ode to get there faster.

What Ode built: Config Newton

Ode worked with LogicGate's implementation and engineering teams to build Config Newton, an agentic assistant that can turn customer documents into working software and GRC workflows. Implementers upload call transcripts, requirements documents, and the scope of work, describe what they need in plain language, and Config Newton drafts the applications in Risk Cloud. It draws on LogicGate’s own experience and best practices from thousands of deployments, so what it produces looks like the work of a senior implementer. The implementer in charge then reviews, corrects, and approves, with their feedback applied to a working application instead of starting from scratch.

Config Newton works through four stages, each handled by its own specialized agent, with a coordinator managing the conversation:

1. Understand. It ingests the documents and extracts the customer's requirements and intentions. Information already captured on paper should not have to be re-entered.
2. Template Selection. It identifies the application type and best-fit pre-existing template, so every engagement starts from the same baseline. It builds new configurations only if no template fits.
3. Design. It drafts the full configuration as validated blueprints - workflows (steps, paths, conditions, fields), forms, jobs (triggers, email templates), and access controls (roles, permission sets, groups) - and proposes the design to the implementer in plain language before anything is created.
4. Apply. Once approved, it builds the configuration on LogicGate’s platform directly. Outputs stay editable and exportable so the team can review, adjust, and apply with minimal friction.

Impact

Config Newton is a key step in LogicGate's AI transformation, and the results are showing up in revenue. LogicGate's growth is on track to accelerate by more than 35% in 2026, and it's having its best expansion year ever. Implementation capacity is no longer the ceiling on growth.

"A customer request came in that would have taken me 50 hours. Before Config Newton, I would have needed to tell the customer it'd be over a month before they were set up. I got it done in just a few hours, and their system was in their hands by the end of the week. I’ve been super impressed by the work Ode has done with the LogicGate team to make this happen and delight our customers."

— Charlie Meyer, Implementation Team Lead

In addition to revenue growth, the LogicGate implementation team has seen:

• 25% increase in number of projects year-over-year. With initial configuration handled by Config Newton, the implementation team has been able to increase throughput of customer deployments and reallocate saved time to additional customer initiatives.
• Expert time went back to strategic work. Implementers no longer spend their days executing thousands of clicks; they review, steer, and correct. The team can now spend their time doing what they’d rather be doing: building strategic relationships with customers and architecting systems.
• Best practices become the norm. When specialists interpreted the same requirements differently, the variation and extra review cycles slowed implementation down. Config Newton applies the same logic every time - reducing variation, making new specialists productive sooner, and making so one implementer’s learnings can compound across the team.
• LogicGate owns the system outright. Code, evaluation tooling, and observability were delivered into their own infrastructure. Their team can monitor, extend, and improve it with no ongoing dependency on Ode.

How we built Config Newton

The implementation team shared with us the parts of the job they hated most, and asked us to start with those. So we used that feedback in the initial build, kept iterating with the team, and collaborated on a tool they now use daily (because it removed the parts of the work they asked us to remove).

The technical challenges to build that system were more subtle. The first engineering question we faced was whether Risk Cloud’s existing API could support an agent. Like most SaaS APIs, Risk Cloud’s API had been designed for a person clicking around. Each call was scoped to do one small thing, so building a workflow would take hundreds of calls in the right order. And in the opposite direction, a single read could return so much data that it would overflow any agent’s context window.

To address this, we set one rule: no agent ever calls the Risk Cloud API directly. Everything passes through a translation layer we built that works when reading and writing.

When the agent wants to create or change something, it writes a structured object ("this workflow, with these steps and these fields”). The translation layer is what breaks that object into the dozens to hundreds of API calls needed to make it work.

And when the agent wants to read something, the layer runs in reverse. It takes the API's large responses and shrinks them into small, focused objects the agent can reason about. Some operations need only a thin translation. Others need much more. 

Open-ended analytics type questions needed the most.

A user might ask: "Which of my vendors haven't completed their assessments this year?" The answer technically exists in Risk Cloud, but no single API call could return it due to the default shape of data in Risk Cloud. And LogicGate couldn't realistically build a new endpoint for every question a customer might think to ask.

Risk Cloud stores its records in Neo4j, a graph database. That makes sense for a product where every record links to other records. But we’ve found agents are far more reliable at writing SQL than graph queries.

For these read-only questions, the translation layer springs into action. It loads the relevant records into a fast database that holds tables in memory, and recasts the graph-shaped data as ordinary rows and columns. Then the agent turns the user's plain-English question into a SQL query, and the answer comes back in milliseconds. This means LogicGate can continue to use a graph database where it makes sense, while building a scalable agent-ready database alongside it.

The payoff was immediate.

LogicGate is now able to provide analytics that would have been impractical to build into its frontend. Instead of creating new endpoints and UI for each type of question, one Ode engineer built the capability in two months. What started as a configuration tool became the primary interface for both building applications and asking questions about data.

Why many agents instead of one?

Only one of Config Newton’s agents ever talks to the database. Across the system, every agent gets one narrow job, and we used a single coordinator to manage the conversation and hand off work.

Context management was part of the reason. Even with focused subagents and filtered, compacted objects, some workflows still push past a million-token context window and need compaction. A single engagement can involve more than a thousand objects, each taking a thousand-plus tokens to represent. No window can hold everything, and no model can reason well over everything at once.

But more important than context management, the deciding reason we split work across sub-agents was reliability. Getting the system from working 70% of the time to working more than 98% of the time was only possible by cutting each agent's responsibility down to a narrow task, then aggressively building evals for every variation of that task. These narrow responsibilities then bought us observability. When each agent owns a clear responsibility, we can see where a workflow failed and improve that piece without guessing.

Both of these, the translation layer and the split into narrow agents, were judgment calls. If a client has a clean, read-only SQL replica, an agent should probably query it directly. In other cases a small API change is enough. For LogicGate, a translation layer was the right path. But the right answer is constantly changing as models and infrastructure change, so as engineers at Ode, our job is to make the best call for the client in front of us, and to revisit it as the field moves.

Conclusion

LogicGate came to us with a mission to transform their company around AI. They knew that unblocking their implementation team was their highest priority, but by no means was it the only opportunity for growth. 

While we built Config Newton, LogicGate’s engineers onboarded to Claude Code. This year, they’ve shipped 50% more requests with the same team size, and they’re so far ahead of schedule, they started their 2027 roadmap early. Building on its initial success with Claude Code, LogicGate is deploying Claude company-wide, giving every employee, from engineering to sales to customer success, access to AI-powered tools that enhance how they work.

“The Ode partnership has been transformative for us. With Config Newton, we’re deploying LogicGate customers faster than ever, driving immediate ROI while boosting satisfaction for both our clients and internal teams. As we continue to embrace AI, we've found that focusing on time savings is short-sighted. The real value is that our people are able to take on entirely new types of work.”

— Diego Panama, LogicGate CEO

That’s how we approach every engagement at Ode. We go deep, engineering custom systems for the problem that matters most to a business. And we go broad, putting AI tools in the hands of every employee.

If this sounds like work you'd want to do, we're hiring.