AI

Facundo Spira and Camila Pérez • 12 NOV 2026

AI Agent Integration Architecture with MCP

post cover picture

AI Agent Integration Architecture with MCP

Accounting firms run on fragmented systems. Client data lives in QuickBooks. Documents are scattered across Google Drive and DropBox. Time tracking happens in one tool, invoicing in another, and project management in a third. When a partner needs to know “Which clients have overdue filings?” or “How many billable hours did we log for Client X last quarter?”, someone has to manually dig through multiple systems to piece together an answer.

This is the problem BetterFirm set out to solve: an AI-powered workspace that connects all your firm’s tools and lets you query across them from a single chat interface. But to make that vision work, BetterFirm needs to actually talk to those tools, not just display their data, but understand their capabilities and act on them.

This is where AI agent integration becomes critical. The challenge isn’t just connecting APIs, it’s designing integrations that allow reasoning, execution, and structured interaction across operational systems.

When it came time to integrate with ModernPM, a practice management platform built specifically for accounting firms, we faced a choice: build a traditional API integration, or try something different. We chose MCP (Model Context Protocol), and this post explains why and how our AI software development team built it.

What is AI Agent Integration?

AI Agent integration is the process of connecting an AI system to operational software so it can:

This goes far beyond embedding a chatbot.

A real integration must allow the agent to reason about tools, decide which operations to execute, and safely interact with production systems.

In our case:

The Players: ModernPM and BetterFirm

Before diving into the technical approach, it helps to understand what these two products do and why connecting them matters.

ModernPM is a practice management software designed for the specific workflows accountants deal with daily. It handles the core operations of running a firm: assigning owners to engagements, tracking deadlines, logging billable hours (via smart timers, calendar shortcuts, or voice entry), and managing invoicing whether subscription-based, milestone-based, or traditional time and materials. Everything lives in one dashboard: client status, project health, team workload, and billing. ModernPM also exposes APIs, which means its data is accessible programmatically.

BetterFirm is an AI agent for accountants. Instead of clicking through the dashboard and running reports, you ask questions in plain English: ”Which contracts are expiring in the next 6 months?”, “What’s my team capacity this week?”, “Which clients have unpaid invoices over 30 days?” BetterFirm connects to your existing tools: QuickBooks, Xero, Google Drive, Slack, and more, and pulls answers from across all of them. It also supports Smart Tasks: automated workflows that run on schedules, like generating quarterly tax reports or weekly billing summaries. The platform is SOC-certified and built with enterprise security in mind.

ModernPM holds the practice management data: projects, time entries, invoices, deadlines. BetterFirm is the interface where accountants ask questions and trigger actions. For BetterFirm to answer “How many unbilled hours do we have for Client X?”, it needs to reach into ModernPM and fetch that data. For it to “Create a follow-up task for Client X next Tuesday”, it needs to write back to ModernPM.

The question is: what’s the best way to build that bridge?

Why We Chose MCP for AI Agent Integration

The traditional approach would be a custom API integration, similar to what many companies implement when structuring complex product architectures.

Write code that calls ModernPM’s REST endpoints, parse the JSON responses, and pipe the data into BetterFirm. This works, but it has a fundamental limitation: the integration can only do what the developer explicitly coded. Every new query or action requires more code.

MCP (Model Context Protocol) offers a different model. Instead of hardcoding every possible interaction, you expose capabilities as tools that an AI can discover and use dynamically. This approach better supports scalable AI agent integrations and long-term flexibility in modern AI development projects.

What is MCP and How Does it Work?

Think of MCP as a universal adapter for AI, as originally introduced by Anthropic. Before MCP, connecting AI assistants to external tools meant building custom integrations for each one, and rebuilding them whenever something changed. MCP standardizes this: you build one MCP server for your tool, and many MCP-compatible AI assistants.

The protocol works in four steps:

  1. Discovery: The AI asks the MCP server “What can you do?” and receives a list of available tools and their schemas.
  2. Request: When the AI needs something done, it sends a structured request following the MCP specification.
  3. Execution: The MCP server performs the operation, querying a database, creating a record, fetching data.
  4. Response: Results come back in a standardized format the AI can parse and use.

Why This Matters for AI Agent Workflow Automation

BetterFirm isn’t a static dashboard. It’s an AI agent that reasons about questions. When you ask “How many billable hours were logged for Client X this month?”, the AI needs to:

With an MCP, we don’t hardcode these paths. We expose ModernPM’s capabilities as tools: “I can list projects, fetch time entries, check invoice status, get client details”. The AI discovers these tools and decides which ones to use based on the user’s question. If we add a new capability to the MCP tomorrow, the AI can use it immediately, no changes to BetterFirm’s core code.

This is where the difference between agents vs workflows becomes practical: instead of rigid business process automation, you enable adaptive AI agent workflow automation.

What the Integration Enables

With the ModernPM MCP in place, BetterFirm users can ask questions and trigger actions across their entire practice management workflow.

The AI doesn’t need pre-built reports for each of these. It queries ModernPM through the MCP, combining and filtering data as needed to construct an answer.

Beyond Queries: Agentic Actions

The MCP isn’t read-only. It also enables BetterFirm to take actions inside ModernPM:

This is what “agentic” means, and it’s the core of agentic AI development: the AI doesn’t just answer questions, it executes workflows across connected systems. The MCP makes this safe and controlled, with proper authentication and audit trails for every action.

Wrapping Up: From API Integration to Scalable AI Agent Integration

Integrating BetterFirm with ModernPM could have been a straightforward API integration. Instead, we built an MCP, and the difference matters.

For accounting firms, this means the integration isn’t a black box. It’s a transparent, extensible bridge between practice management data and an AI assistant that can actually reason about that data. As ModernPM adds new features, the MCP can expose them as tools without waiting for a BetterFirm release. As BetterFirm’s AI capabilities improve, it can use those tools in more sophisticated ways. MCP turns what would have been a static pipe into a living connection.

That’s the kind of foundation you want when you’re building AI that’s meant to grow with your firm and the kind of architectural decision companies often evaluate when looking for an experienced AI agent development company.

Frequently Asked Questions About AI Agent Integration

What is AI agent integration?

AI agent integration connects AI systems with operational software so they can retrieve data, trigger actions, and reason across systems.

How is AI agent integration different from traditional API integration?

Traditional API integrations are hardcoded. AI agent integrations expose capabilities dynamically, allowing the AI to decide how to interact with systems.

What is MCP?

MCP (Model Context Protocol) is a standardized protocol that allows AI systems to discover and use external tools dynamically.

When do companies need AI agent integration?

Companies need AI agent integration when AI systems must operate inside production software, not just answer questions.

Building AI Agent Integrations the Right Way

It’s not just about connecting APIs. It’s about designing an architecture that can scale, evolve, and support real operational workflows.

If you’re exploring how to integrate AI agents into your product or internal systems, we help companies design and implement AI agent integrations that reduce technical risk and grow with the business.

 

Stay updated!

project background