AI
Facundo Spira and Camila Pérez • 12 NOV 2026
AI Agent Integration Architecture with MCP

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:
- Discover system capabilities
- Retrieve structured data
- Trigger actions
- Maintain context across interactions
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:
- ModernPM holds structured operational data
- BetterFirm acts as the reasoning layer
- MCP becomes the integration protocol between them
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:
- Discovery: The AI asks the MCP server “What can you do?” and receives a list of available tools and their schemas.
- Request: When the AI needs something done, it sends a structured request following the MCP specification.
- Execution: The MCP server performs the operation, querying a database, creating a record, fetching data.
- 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:
- Understand that this question requires time tracking data
- Know that ModernPM is the system that holds this data
- Call the right operation to fetch the information
- Format the response in a way that makes sense
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.
- Workload & Capacity: “Which team members are overbooked this week?”/ “What projects are behind schedule?”
- Time & Billing: “How many unbilled hours do we have for Client X?”/ “What’s our realization rate this quarter?”
- Client Health: “Which clients have unpaid invoices over 30 days?”/ “When is the next deadline for ABC Corp?”
- Project Status: “Give me a summary of all active engagements”/ “What tasks are due this Friday?”
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:
- Create tasks from chat (“Add a follow-up task for Client X next Tuesday”)
- Log time entries based on calendar events or detected work
- Trigger billing workflows (“Generate an invoice for all unbilled time on Project Y”)
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.

