When a Technical Account Manager at Modern Treasury receives a complex customer question about payment failures or transaction anomalies, the investigation can require moving across several internal systems. Modern Treasury's Bank Operations Agent now decomposes the request, selects the relevant systems, and queries them in parallel. It can work across Notion, Hex, Linear, Sentry, Devin, Zendesk, and Slack, then synthesizes the evidence for human review. Built using MintMCP Coworker Agents, with tool access running through MintMCP's MCP Gateway, this implementation demonstrates how a financial technology company can add a governed agent layer to its existing tools. MintMCP's Agent Gateway provides the control layer for agent identities, permissions, memory, and monitoring.

This article breaks down the architecture, implementation elements, and governance approach Modern Treasury used to deploy agents in production.

Key Takeaways

• Modern Treasury's Bank Operations Agent saves 30 to 60 minutes on simple process and webhook questions and 2 to 4 hours on complex, multi-system cases
• Modern Treasury built the agent using MintMCP Coworker Agents, with tool access running through MintMCP rather than a bespoke integration layer for every internal system
• Modern Treasury's architecture closely resembles a "smart overlay" because it connects an agent to existing internal tools rather than rebuilding the underlying systems
• Human-in-the-loop approval gates ensure all customer-facing communications require review before sending, maintaining quality while enabling autonomous internal actions
• Each tool has a defined "epistemic role" telling the agent what that system is for, reducing irrelevant queries and improving investigation quality
• Agent identity and credential management through MintMCP's governance architecture ensures proper audit attribution and credential hygiene at scale

What a Bank Operations Agent Does and Why It Matters

A Bank Operations Agent is an AI system that autonomously investigates operational questions by querying multiple internal systems, synthesizing information, and recommending or taking actions. Unlike chatbots that answer questions from a static knowledge base, these agents execute multi-step workflows across live production systems.

Modern Treasury's implementation handles the specific challenge faced by Technical Account Managers: when a customer asks "Why did this payment fail?" or "What's causing these reconciliation errors?", answering requires checking documentation in Notion, running queries against production data in Hex, reviewing error logs in Sentry, checking issue status in Linear, and potentially verifying code behavior through Devin. Previously, this meant opening multiple browser tabs and manually correlating information.

The business case is straightforward:

• The agent saves roughly 30 to 60 minutes on simple process and webhook questions and 2 to 4 hours on complex, multi-system cases
• Parallel queries reduce the time spent moving between relevant systems
• Defined epistemic roles keep documentation, code, production data, roadmap history, and runtime signals separate
• Evidence-backed results help engineering teams start from a scoped problem rather than a cold handoff

The agent addresses these issues by querying relevant systems in parallel, keeping each source's role distinct, and escalating unresolved ambiguity instead of guessing.

Smart Overlay vs. Process Redesign

Deloitte's framework for agentic AI in banking identifies three implementation approaches: smart overlay, agentic by design, and full process redesign. Modern Treasury does not use this label in its public write-up, but its architecture closely resembles the smart overlay path because it layers an agent across existing tools rather than replacing the underlying systems.

When smart overlay makes sense:

• Your team has well-defined standard operating procedures
• Existing tools have API access and stable schemas
• You need quick wins before committing to larger transformation
• The process bottleneck is human coordination, not tool limitations

When to consider alternatives:

• Building new products where agent capabilities are core features
• Legacy systems fundamentally block automation
• You have budget and timeline for full process transformation

The Technical Architecture Behind Multi-System Agent Orchestration

Modern Treasury's agent uses MintMCP to access tools through the Model Context Protocol (MCP). MCP standardizes how AI applications discover and invoke tools, while MintMCP's gateway centralizes authentication, access control, credential handling, and audit logging across those connections.

Epistemic Roles: Teaching the Agent What Each Tool Is For

A critical design decision was assigning each integrated tool an "epistemic role" defining what that system represents:

• Notion serves as the documentation source for policies, procedures, and historical context
• Hex provides production data analysis capabilities for investigating actual customer transactions
• Linear tracks issue status and engineering work items
• Sentry surfaces runtime signals, errors, and exceptions
• Devin verifies code behavior when the agent needs to understand system logic
• Zendesk manages customer communications and ticket history
• Slack enables team notifications and escalation

Without explicit role definitions, agents make inefficient tool calls. An agent might query Sentry for documentation or search Notion for real-time error data. The epistemic role framework prevents these mismatches by giving the agent clear guidance on when to use each system.

Agent Governance and Scoped Tool Access

MintMCP's agent identities system supports per-agent identities, scoped credentials, and agent-attributed audit logs. Modern Treasury's public write-up confirms that the Bank Operations Agent's tool access runs through MintMCP, but it does not disclose the exact Agent Bundle, credential, or policy configuration used for this deployment.

The controls Modern Treasury publicly documents include:

• Read-only production access: Hex runs read-only queries against production and analytics data
• Tool-specific roles: Each system has a defined epistemic role so one source does not substitute for another
• Human review: Zendesk tickets are drafted rather than auto-filed, and a human reviews anything that leaves the agent's state

Building the Agent: Tools, MCP, and Implementation

Modern Treasury has not published a detailed week-by-week implementation timeline. Its engineering write-up confirms the following implementation elements:

Publicly Documented Implementation

• Build the agent using MintMCP Coworker Agents
• Connect Notion, Devin, Hex, Linear, Sentry, Zendesk, and Slack
• Assign a specific epistemic role to each tool
• Decompose requests and query relevant systems in parallel
• Keep Hex access read-only
• Require human review before anything leaves the agent's state
• Refine instructions when TAM feedback reveals gaps

General Implementation Risks to Plan For

Modern Treasury's public write-up does not identify the following as problems it encountered, so they should be presented as general deployment risks rather than case-study findings.

Tool API rate limits: Parallel calls can trigger vendor limits. Use documented backoff, throttling, and quota controls, and test each integration under expected load.

Permission mismatches: Agents should not automatically inherit a human user's full permissions. Use agent-scoped credentials and explicitly map the minimum permissions required for each tool.

Escalation calibration: Start conservatively, measure both false escalations and missed escalations, and adjust thresholds only after reviewing real cases.

Security and Governance for Financial Services AI

Financial services companies operate under stringent compliance requirements. Modern Treasury lists Dependable AI, Inc. dba MintMCP as a subprocessor and describes it as an AI governance platform. The listing confirms the vendor relationship but does not document the Bank Operations Agent's complete architecture or control configuration.

Human-in-the-Loop for High-Stakes Actions

Modern Treasury's agent follows a clear rule: anything customer-facing requires human approval before sending. The agent can draft Zendesk responses and prepare communications, but a human reviewer validates before the message goes to the customer.

This approach balances automation benefits with quality control:

• Agent-executed work: Cross-system evidence gathering, read-only Hex queries, Zendesk ticket drafts, and instruction updates triggered by TAM feedback
• Human-reviewed work: Anything that leaves the agent's own state, including customer-facing communications and filing Zendesk tickets

Audit Trail Requirements

For financial services, audit trails are not optional. MintMCP documents audit logs for MCP interactions, access requests, configuration changes, tool calls, authentication events, credential changes, and access grants. Agent Monitor separately records coding-agent tool calls, file access, and command execution.

Modern Treasury's public case study does not publish the exact audit fields enabled for this Bank Operations Agent. The supported claim is that MintMCP provides attributable activity and access logs for governed agent and MCP interactions, not that hidden LLM reasoning steps are recorded.

Building proper audit trails for AI agents requires capturing this level of detail. Without it, compliance teams cannot demonstrate proper controls over agent behavior.

Self-Improving Instructions from Human Feedback

Modern Treasury says the agent updates its own instructions when a TAM correction reveals a gap. This creates a feedback loop in which human corrections improve future behavior.

The public write-up does not specify a separate approval workflow for each instruction change, so the claim should remain limited to feedback-driven instruction updates.

From Manual Workflows to Agent-Assisted Operations

The transition from manual support workflows to agent-assisted operations requires minimal data migration because the agent queries existing systems on-demand. The main preparation work involves documenting SOPs and tribal knowledge as agent instructions.

Rollout Guidance

Modern Treasury's public write-up confirms internal deployment but does not describe a formal parallel-run period, a small-team pilot, or a broader TAM expansion sequence. For teams adapting this pattern, a staged rollout can compare agent output with manual investigations, capture edge cases, and expand access after evidence quality and escalation behavior stabilize.

Scaling the Governance Layer

As usage expands, MintMCP's MCP Gateway centralizes governed tool and data connections, while Agent Gateway adds agent identities, permissions, memory, and monitoring. This is MintMCP's product model, not a documented claim that Modern Treasury scaled the deployment without additional engineering work.

Measuring Success: ROI and Performance Metrics

The primary ROI metric is time saved per investigation. The 30 to 60 minutes saved on simple questions and 2 to 4 hours on complex cases translate directly to TAM productivity. With multiple investigations per TAM per day, the cumulative time savings is substantial.

Secondary Metrics

Beyond time savings, useful metrics for a similar deployment include:

• Investigation thoroughness: Does the agent check all relevant systems? Manual investigations often skip systems due to time pressure.
• First-response accuracy: How often does the agent's initial analysis lead directly to resolution?
• Escalation rate: What percentage of queries require human intervention? Declining escalation rates indicate improving agent capability.
• Engineering handoff quality: Do engineering tickets contain sufficient context from agent investigations?

Modern Treasury reports roughly 30 to 60 minutes saved on simple process and webhook questions and 2 to 4 hours on complex, multi-system cases. These figures are specific to its workflow and should not be generalized to other financial operations deployments without comparable evidence.

Cost Structure

Direct costs can include MintMCP's custom-priced licensing and platform fees, LLM usage, and any tool-specific API or data charges. Implementation costs depend on connector setup, permission mapping, evaluation, and ongoing operations.

Because the available sources do not disclose Modern Treasury's staffing costs, investigation volume, MintMCP contract value, or model usage, they do not support a specific break-even period.

A defensible calculation is:

Monthly labor value = cases per month × average time saved per case × fully loaded hourly cost

Compare that value with monthly platform, model, integration, and operational costs.

Implementation Lessons

Start with Clear SOPs

The agent works because each tool has a defined role. Teams without documented procedures struggle to translate implicit knowledge into agent instructions. Before implementation, document:

• What systems get checked for which question types
• What data points are required for complete answers
• When to escalate versus resolve independently
• Quality standards for customer communications

Begin with High Escalation, Then Tune Down

Conservative initial settings mean the agent asks humans frequently. This is intentional. Early over-escalation:

• Builds human trust in the system
• Reveals edge cases for instruction refinement
• Prevents errors during the learning period
• Provides training data for threshold adjustment

As patterns stabilize, teams reduce escalation thresholds incrementally.

Review Agent Logs During Ramp-Up

During initial rollout, review logs frequently enough to identify repeated tool-selection errors, instruction gaps, approval friction, and integration failures:

• Missed opportunities for automation (queries that could run without approval)
• Incorrect tool usage patterns
• Instruction gaps revealed by novel query types
• Performance bottlenecks from specific tools or queries

Reduce the review cadence only after quality, escalation, and integration metrics stabilize.

How MintMCP Enables Agent Governance at Scale

Modern Treasury's Bank Operations Agent shows how MintMCP separates tool governance from agent governance:

• The MCP Gateway provides governed access to Notion, Hex, Linear, Sentry, Devin, Zendesk, Slack, and other enterprise systems.
• The Agent Gateway adds dedicated agent identities, scoped permissions, persistent memory, and monitoring.
• Coworker agents can operate in Slack, retain context across days, and work alongside employees.

Together, these layers give teams centralized control over how agents access internal systems. Tool calls can be attributed to the correct agent identity, evaluated against defined access policies, and recorded in audit logs.

Modern Treasury also applies workflow-specific safeguards:

• Hex queries remain read-only.
• Anything leaving the agent's state requires human review.
• Each connected system has a defined role in the investigation.
• Ambiguous cases are escalated instead of resolved through unsupported assumptions.

MintMCP provides the reusable governance foundation behind these workflows, including agent identities, centralized authentication, scoped tool access, and attributable logging.

This allows teams to expand from individual agent workflows to broader deployments without rebuilding authentication, permissions, and audit controls for every new use case.

Frequently Asked Questions

Can this approach work for companies without existing API access to their internal tools?

The approach requires a supported integration path, such as an API, MCP server, database connection, or another controlled automation interface. API availability, scopes, rate limits, and commercial terms vary by vendor and subscription, so teams should verify each system individually rather than assume business or enterprise tiers include the required access.

How does the agent handle situations where different tools return conflicting information?

The agent keeps each source's epistemic role separate and escalates unresolved contradictions or ambiguity. Modern Treasury describes a bank-check question where code showed two existing configurations, but the request was ambiguous between an SFTP channel and a newer REST product. The agent left the question open pending TAM clarification rather than guessing.

What happens when the underlying LLM makes reasoning errors?

LLM reasoning errors manifest as incorrect tool calls, misinterpretation of results, or flawed conclusions. The human-in-the-loop approval gate catches many of these before they reach customers. For internal actions, the audit trail enables post-hoc review. Teams can add validation layers for high-stakes operations, such as requiring approval of the proposed query, affected data scope, cited evidence, and intended action before a write or sensitive database operation.

How do you handle tool API changes that break agent functionality?

MCP schemas make expected tool inputs and outputs explicit, but they do not eliminate vendor API changes or integration breakage. MintMCP provides hosted MCP server and lifecycle-management capabilities, while teams should still use schema tests, version checks, health monitoring, and explicit fallback behavior for critical integrations.

Can multiple agents share access to the same tools, and how is that coordinated?

Yes, multiple agents can access the same underlying tools through MintMCP's gateway. Agent Bundles can give each agent its own identity, scoped tool connections, token, and audit trail. MintMCP also documents gateway rate limiting and quota controls. Avoid claiming request queuing or per-agent quota behavior unless those capabilities are confirmed in the applicable product documentation.