Trabian
Mesh Integration Platform
This document is for the people who'll actually decide how Trabian and Black Flag work together: Aaron, Matt, and Trey on the Trabian side; Eli and Keith on ours. It picks up from the April 29 working call between Keith and Aaron, and frames the partnership in the language both sides used on that call: "Mesh is the platform that allows for AI speed against compliance and regulated systems." That's the deal. Mesh stays the governed substrate. Black Flag is the AI application, agentic workflow, and facilitation layer that turns the substrate into shipped client outcomes — apps, not integrations. Everything else in this folder (One Pager, SOW, Security Posture) descends from the thesis on this page.
The two sides of this partnership already do the thing the other side doesn't want to do. Aaron framed it on the April 29 call: "a firm that does what you do doesn't want to do what we do, and we can't do what you do because we're doing all of this." That's why this is clean, not why it's complicated. Trabian isn't positioned to build apps for clients — and shouldn't be. Black Flag isn't positioned to run a bank's core connections — and shouldn't be. Together, the line is bright.
Mesh is, in Aaron's own framing, "the platform that allows for AI speed against compliance and regulated systems" — all the logging, all the connections to cores, payments, and partners, baked in. Jack Henry, Q2, Fiserv, Alkami. Licensing deals to get fintechs into Q2 and Alkami, not just talk to them. That ecosystem is on lock. The stability is what gives an application layer permission to move fast.
Black Flag's job is everything that sits above that line: facilitation, AI use-case shaping, application development, agentic workflow design with human-in-the-loop guardrails, demos that win procurement, and the slow grind of getting an FI's people to actually adopt the thing. We take partners from vague idea → facilitated clarity → prototype → alpha → beta workflow → production AI application, using Mesh as the substrate underneath. Keith's framing on the call: "we can go from nothing to alpha better than anybody else."
The Connecticut bank-analysis startup that surfaced on the call is exactly the shape of client this is built for. Real product to build (an analysis platform a state controller wants every Connecticut bank reporting against), real banks already on the hook, regulators paying attention — and a team that doesn't have the application + AI muscle to ship the front half. Mesh gets them connected to cores and CRMs. Black Flag builds the product.
Trabian owns the stable financial-services infrastructure. Black Flag owns the AI application and adoption layer on top. The two halves combine into one complete delivery motion for any bank, credit union, or fintech client — without either side having to step into a business model that isn't theirs.
flowchart LR
Client["Bank · CU · Fintech
(has an AI use case)"]
BFD["BLACK FLAG
Application Studio
Facilitation · App build · Adoption"]
Mesh["TRABIAN / MESH
Banking Substrate
Connectivity · Logging · Compliance"]
Cores["Cores · Payment Rails
Q2 · Jack Henry · Fiserv · CSI · Alkami"]
Client ==>|asks for AI app| BFD
BFD ==>|ships app, owns adoption| Client
BFD -.->|rides the substrate| Mesh
Mesh -.->|governs connectivity| Cores
classDef bfd fill:#1E5BB8,stroke:#4985d8,stroke-width:2px,color:#FAFAFA;
classDef mesh fill:#1A1A1A,stroke:#4985d8,stroke-width:2px,color:#FAFAFA;
classDef ext fill:#0A0A0A,stroke:#3A3A3A,stroke-width:1px,color:#A1A1AA;
class BFD bfd;
class Mesh mesh;
class Client,Cores ext;
The arrows that matter most: solid to and from the client (BFD is on the hook for the application and the adoption); dashed to Mesh (BFD consumes the substrate, doesn't operate it); dashed onward to cores (Trabian governs the connectivity, BFD never has to).
Four moves, in twelve months, walked Trabian from "custom dev shop" to "platform operator with a workflow-management roadmap." Each one widened the surface area where an application studio like Black Flag can plug in.
Per IBJ, the pre-Mesh shape was "everyone was bespoke, custom-built." Twenty years of trusted FI engineering, but every project was a snowflake.
Repurchased shares from MVB Bank. Free to define a platform-led future on its own terms — without a bank-side cap table dictating direction.
Bought from Core10. Inherited core connectivity (Jack Henry, Fiserv, CSI) and licensing deals into Q2 and Alkami. Months-not-years became a real claim.
Trabian's stated direction shifted: morph from integration platform → workflow management platform. Reliability + accountability + time-to-market for FIs and fintechs.
Mesh is already in production, already serving customers, already connecting cores. The remaining gap — the one a banker or a fintech CEO actually feels — is the application layer on top: the screens, the agents, the workflows, the human-in-the-loop copilots that make Mesh tangibly valuable to a buyer. Trabian doesn't want to staff a 30-person app-build org to fill that gap; it wants a partner that can. That's where Black Flag sits.
Frame the partnership as a shared services lane Trabian can sell, staff, and showcase. Black Flag operates as the embedded AI-application studio for Mesh, taking client ideas through a repeatable motion that respects Trabian's governance posture at every step.
Vague client idea becomes a defined workflow, agent policy, and risk register.
BFD prototypes the experience. Mesh defines available infra, data, and actions.
BFD builds. Mesh governs integration, security, platform fit. Synthetic data first.
Client tests usage. Successful patterns become repeatable Mesh-backed modules.
Each successful build becomes a candidate repeatable module — sold across the 200+ relationships Trabian already has, demoed to prospects evaluating Mesh, and used as evidence the platform actually ships application-layer outcomes.
Not a buffet of seven. Three deeply-told stories, each pegged to a real customer already in the Mesh / Trabian / Q2 / Jack Henry orbit. Each is narrow, sandbox-safe, human-in-the-loop on day one, and answers a question those banks are already asking. Every one of them deliberately leans into Black Flag's two unfair advantages: we go from nothing to alpha faster than anybody else, and we manage agents that write the software — which is how a five-person team ships work other firms need thirty to ship.
The real story. Core10's published Encore Bank case study describes the squeeze: commercial bankers losing days between first conversation and wired funds because borrower context lives in CRM, core, and LOS — and never in the same place. Encore was Mesh's documented win on closing that gap. (Disclosure: Keith was CTO at ZSuite when Junod was there; ZSuite served Encore. We know this customer's shape.)
What Black Flag would build. A banker workspace on Mesh that pulls context out of CRM + core + LOS, summarizes the borrower in plain English, drafts the next RM action, and stages docs for compliance review. Read-only against production for the first 60 days. Synthetic data for the alpha. Every drafted action gated by a human click. Mesh handles the connectivity; we ship the UI, the agent policy, the workflow contract, and the adoption playbook.
Win condition at 90 days. Time from first conversation → wired funds drops, and the banker on screen says "this is faster than the spreadsheet." Reusable as a Mesh-backed module across other commercial-lending FIs.
The real story. UCCU's Q2 case study (a Trabian/Q2/Jack Henry collaboration) reports premium-checking adoption jumping from 8% to 37% in month one — driven by a digital banking feature shipped fast, with stakeholder alignment, on top of Mesh-adjacent infra. That motion is rare, replicable, and exactly what every other mid-size CU is asking Trabian for next.
What Black Flag would build. Productize that motion as a "feature launch studio" engagement: a 2-week facilitated discovery sprint, a clickable prototype, an AI-personalized member-facing experience layer, and an in-product adoption loop. Eli runs the room; agents do most of the build; the CU walks out with a launched feature and the analytics to defend the budget.
Win condition at 90 days. A second CU launches a measurably-adopted feature on the same studio motion, and the third one signs without a discovery call because the playbook is now real.
The real story. The April 29 call surfaced a Trabian referral candidate (Braxton-network, ex-Vice Media founder): an analysis platform sold to one Connecticut bank, now being pulled by COCC and the state controller toward "every CT bank reports against this once a quarter." They have data people, but not enough. They have a product, but not the team to scale it. Aaron's read on the call: "we are not well positioned for this — but you are."
What Black Flag would build. The application layer end-to-end: web app, mobile companion, a backend that ingests cohort data through Mesh from CRMs and cores, the AI models and pipelines that turn the cohort data into the insights regulators want, and the human-in-the-loop review surface for bank staff. Mesh handles the connectivity into every CT bank's stack — the part the startup couldn't have built itself in time. Black Flag handles the product the controller actually sees.
Win condition at 90 days. The startup ships an alpha that the originating bank uses for one real cohort report. Aaron has a referenceable joint engagement; we have a wedge into every other CT bank that will be required to file the same report.
The shape across all three: Trabian sells the platform, refers the application work, and sees revenue from both sides — without taking on the headcount or business model of an apps shop. Black Flag ships the apps, manages the agents that wrote them, keeps the FI's compliance posture intact, and turns each engagement into a reusable Mesh-backed module the next ten clients can buy off a shelf.
Trust gets built one stage at a time, and the timeline below in section 08 traces what that looks like for a single 90-day engagement. Across all three engagements in section 05, the same pattern applies: crawl in synthetic data, walk on a real alpha with a design partner, run as a productized Mesh-backed module. Each step earns the next.
Workshop, workflow map, agent policy card, prototype, risk register. No real customer data ever touched. Output: a demo Aaron and the team can show internally.
One FI or fintech from Trabian's 200+ relationships agrees to be the design partner. Custom AI app alpha → user testing → human-in-loop beta. Real users, governed scope.
Successful pattern becomes a repeatable Mesh-backed module sold across the 200+ FI base. Demo library, governance framework, partner enablement kit, commercial packaging.
Every custom AI application ships with an agent policy card: business purpose, user role, data sources, permitted/prohibited behaviors, allowed actions, actions requiring human approval, logging, failure modes, escalation path, retention model, success metrics. Early work lives at Levels 0–3.
The chart below is the real shape of one of these engagements — applied to any of the three stories in section 05. Defined, low-risk, fixed-fee. Synthetic data through day 60. Clear go/no-go on day 90 — design partner identified and beta scope agreed, or a clean exit. Crawl, walk, run mapped to the timeline rather than treated as an abstract ladder.
The work isn't just "the model" — it's the full delivery: web app + mobile companion, backend, the workflows and data contracts between Mesh and the client, the stakeholder management that gets the FI's people on the same page, and the agent governance that keeps compliance teams calm. The differentiator across all of it: BFD's team manages agents that write the software. That's how a five-person shop runs at the velocity of a thirty-person one — without sacrificing the compliance posture banks need.
gantt
title AI APPLICATION DELIVERY · TRABIAN + BLACK FLAG (90-DAY ALPHA)
dateFormat X
axisFormat Day %s
section Crawl · BFD-led
NDA + Mesh orientation :crawl1, 0, 10
Use-case workshop + workflow map :crawl2, 5, 18
Agent policy card + risk register :crawl3, 10, 24
Clickable prototype + demo script :crawl4, 14, 30
section Walk · Joint
Backend + data contracts (Mesh ↔ client) :walk1, 22, 50
Web app + mobile companion build :walk2, 28, 60
Synthetic-data alpha :walk3, 35, 60
Internal user feedback + iteration :walk4, 45, 60
section Run · Design partner
Design partner identified (from 200+ FIs) :run1, 55, 68
Integration + compliance gating :run2, 60, 82
Production data, governed scope :run3, 70, 90
Adoption playbook + reusable module spec :run4, 75, 90
What the chart doesn't draw, but matters: every cell that has BFD building, has BFD agents building under BFD oversight. That's the speed multiplier that makes 90 days realistic on a custom AI app where most shops would quote nine months.
Everyone who's reading this — Aaron, Matt, Trey, Eli, Keith — already knows the thesis. The remaining question is whether there's a small real thing the five of us could build together in the next 30 days that would tell all five whether this works. The Connecticut bank-analysis referral is one obvious shape; an internal Mesh demo app is another. We're flexible on the wedge; we're firm on doing one.
One concrete next step: a 45-minute working session with the five names on this document. Goal — pick the wedge, shape the 30-day boundary, agree the rough commercial frame. We bring a one-page scoping template; you bring the candidate client (or the internal target). We leave with something on the calendar.
Print-ready partnership brief. Hero, stats, capabilities, 90-day path, CTA. Forward to Matt, Trey, or anyone who needs the shape in 90 seconds.
Open →Pilot SOW scaffold. Editable scope, fees, and cadence — we'd shape the real one around the first joint client we land.
Open →Architecture + data-handling answers, pre-filled. Send only if procurement asks — don't lead with it.
Open →