Governed commerce for AI agents

Agents are ready to transact. Give them a front door.

GateCore is the toll gate where the agent economy clears: every request identified, policy-checked, priced, settled, and receipted on a tamper-evident ledger, before it touches your tools, your data, or your money.

Request early access See a transaction clear
ED25519-SIGNED REQUESTS · APPEND-ONLY LEDGER · SIGNED RECEIPTS · PATENT PENDING
EXECUTED
GATECORE · ACTION RECEIPTgatecore-receipt-v1
requestreq_9f27c1
agentagent:acme-research
verifiedsignature · key · freshness ✓
policyALLOW · rule 04
capabilitymarket-briefing · v1.2.0
contractsha256:52ab…e91f
price$0.80
splitowner 80% · platform 20%
SETTLED$0.80
signed · verifiable by any third party
ledger anchor a1c9…44e2 → 7d20…b8c3
Founding cohort

Marketplace registration is invitation-only while the founding cohort forms. Founding members onboard hands-on — tenant, signing keys, and policy stood up with them — and set the conventions the wider marketplace inherits.

Request founding access
How it works

One signed request in. Six guarantees out.

Nothing executes until it has cleared every gate, and everything that clears leaves evidence a third party can verify.

01
VERIFY
Cryptographic identity: Ed25519 signature, replay protection, key & grant lifecycle
PASS
02
SCORE
Trust and provenance, earned from verified outcomes and never self-asserted
0.83
03
ENFORCE
Declarative policy: allow, throttle, modify, hold for human review, or deny
ALLOW
04
RESERVE
Funds held before execution, so you never pay for work that didn't happen
$0.80
05
EXECUTE
The governed action runs, scoped to exactly what the contract permits
200
06
SETTLE
Capture with revenue share, signed receipt, hash-chained ledger entry
RECEIPT

A held action shows REVIEW until a human approves. A refused one shows DENY, with the exact rule that refused it.

Two sides, one gate

Built for both sides of the agent economy.

For teams deploying agents

Delegate spending. Keep control.

Fund an account, set the limits, and let your agents buy the data and capabilities they need. Every purchase is identified, policy-gated, and receipted for finance.

  • Spending limits and approval thresholds your policy enforces
  • Human review, with funds held, for sensitive actions
  • A signed receipt for every purchase: reconciliation without chat-log archaeology
  • Revoke an agent's credential in one call
For data & tool owners

A paid front door for AI.

Your data is already valuable to AI agents. Today they scrape it or skip it. GateCore gives agents a licensed, paid entrance while you keep identity, limits, pricing, revocation, and receipts.

  • List once; every governed buyer can discover and purchase
  • Who may access, for what purpose, at what rate: enforced, not hoped
  • Per-request pricing with automatic revenue share
  • Proof of exactly who received what, under which terms

Block bots at your edge. Give agents GateCore as the licensed way in.

Where buyers come from

Your buyers already have an interface. It's their AI.

GateCore speaks MCP, the open protocol AI assistants use to reach outside tools. A customer connects their funded GateCore account to the assistant they already use, and every purchase it makes is identified, limit-checked, and receipted. The AI is the shopping interface; GateCore is the merchant network and the checkout.

The session can't spoof who it is: identity and trust come from GateCore's records, not the model's claims.

Pull the parcel history and a market brief for 195 N Holiday Rd before tomorrow's meeting.
gatecore · agent identified · policy ALLOW · $0.85 within delegated limit · reserved → captured · receipt req_b41e
Done. Parcel history and market brief attached. The purchase cleared through your GateCore account: two governed transactions, $0.85 total, receipts filed.
Products

Three products. One governed rail.

01
The rail

GateCore Gateway

The governed execution core. Signed agent requests come in; identity, trust, policy, pricing, and funding gates run; the action executes; settlement captures and a signed receipt lands on the ledger. Every agent interaction becomes a governed, priced, provable transaction.

  • Ed25519 identity, replay protection, key & grant lifecycle
  • Reserve-before-execute settlement with automatic revenue share
  • Signed receipts on an append-only, hash-chained ledger
02
The control room

Operator Console

The human side of governance. Operators administer tenants, agents, grants, and keys; write and reorder policy; work the review queue with funds held in escrow; and watch every decision, event, and cent stream through the activity views.

  • Policy administration: every rule change attributed and audited
  • Human review queue for held actions, approve or release
  • Federated activity: transactions, procurement, listings, operator events
03
The storefront

Marketplace + MCP Connector

Governed listings with versioned, hash-stable contracts; discovery and procurement for agent buyers, including straight through the AI assistants your customers already use, over the open MCP protocol, with credential-bound identity that sessions can't spoof.

  • Publish once: draft, publish, version, deactivate, all audited
  • Cross-tenant buying with seller-attributed sales views
  • Machine-readable denials that tell agents how to get governed access
See them working: six use cases →
Platform

The control plane agents were missing.

§1

Cryptographic agent identity

Ed25519-signed requests bound to issued keys and access grants. Replay-proof, freshness-windowed, full key lifecycle.

§2

Policy engine

Declarative, ordered rules: first match wins, hot-reloadable, and every decision names the rule that made it.

§3

Evidence-based trust

Trust moves only on verified outcomes. Agents can't assert it, platforms can't fabricate it, and nobody can buy it.

§4

Usage-based pricing

Config-driven rate cards with per-line-item breakdowns. Every agent action is priced for billing and dispute.

§5

Settlement & revenue share

Append-only, hash-chained ledger. Reserve before execution; capture on success, release on failure; split to owners automatically.

§6

Signed receipts

Every verification, decision, and cent becomes a signed receipt a third party can verify: governance you can prove, not just assert.

The evidence chain

Provable, not promised.

Most governance tools produce logs you have to trust. GateCore produces evidence you can hand to an auditor or a counterparty.

Signed receipts

Each action's verification, policy decision, price, and settlement facts, signed and verifiable without trusting GateCore's word.

Hash-chained ledger

Every cent moves on an append-only, per-account chain. Tampering with history breaks the chain visibly.

Attributed decisions

Every allow, hold, and deny names the rule, the key, and the human (when one was involved). Nothing is anonymous.

Getting live

Nothing installs in your environment.

GateCore is hosted infrastructure: your agents talk to it over signed requests, and we never ship code into your estate. Going live is an operated onboarding, not an integration project.

01
See it run
A working demo against live gates: your use case, real decisions, real receipts.
02
Provision
We stand up your tenant, agents, access grants, and signing keys. Key exchange is the security feature, not the friction.
03
Set policy
A working session to encode your rules: spending limits, review thresholds, who may do what.
04
Go live
Fund the account and accept with a one-cent production transaction, the first entry on your ledger.
05
Evidence
Recurring audit exports of decisions, receipts, and settlement: governance your compliance team can file.
FAQ

Questions, answered.

What is GateCore?
The governed front door for AI-agent commerce: a gateway that verifies identity, enforces trust and policy, prices and settles every action, and records signed, tamper-evident evidence, before anything touches your tools, data, or money.
Can it stop AI scraping of our data?
Honestly: no tool controls data after delivery, and bot-blocking belongs at your edge. What GateCore does is make blocking commercially safe: agents get a licensed, paid entrance with identity, limits, pricing, and revocation, and you get a signed record of exactly who received what, under which terms. Against a scraper you have nothing; against a GateCore buyer you have a contract and an evidence chain.
Can our team buy through Claude or ChatGPT?
GateCore exposes its marketplace over MCP, the open protocol AI assistants use to connect to outside tools. Connect a funded GateCore account and the assistant can discover listings and purchase within the limits you set, with every purchase identified and receipted. The assistant is the interface; your GateCore account is the identity, wallet, and audit trail.
What gets checked before an agent action executes?
Signature, replay, and key lifecycle; trust score; provenance; declarative policy (allow / throttle / modify / hold / deny); contract scope; and funding, with money reserved before execution. Nothing runs until every gate passes.
How do pricing and settlement work?
Funds are reserved before execution, then captured on success or released on failure. You never pay for work that didn't happen. Settlement rides an append-only hash-chained ledger with automatic revenue share to resource owners.
Can a human approve sensitive actions?
Yes. Policy can hold any action for human review with funds in escrow until an operator approves or rejects it; rejection releases the hold. The reviewer's decision becomes part of the signed record.
Can we run GateCore for internal agents only?
Yes. The marketplace is optional. Register your own agents, put your internal tools and data behind the gate, and every internal action gets the same treatment: identity, policy, human review where you want it, and signed receipts. GateCore stays hosted infrastructure either way; nothing installs in your environment. If your security posture requires a privately hosted deployment, talk to us about where that fits.
Can we set prices to zero?
Yes. Pricing comes from a configurable rate card, and zero is a valid price. At $0 the full governance path still runs: identity checks, policy, holds for review, receipts, and the audit trail. Money simply never moves. A common shape is zero-cost governance on internal tools next to per-request pricing on anything listed for outside buyers.
How is this different from a workflow builder or API gateway?
Those connect systems with broad static credentials and no pre-execution trust, policy, settlement, or tamper-evident audit. GateCore governs and monetizes the action itself: identity-bound, priced, reversible-until-executed, and provable afterward.
Early access

The agent economy needs a clearinghouse. We built it.

GateCore is live with early partners: sellers listing governed capabilities, buyers transacting through the agents they already use. Tell us which side you're on.

Request early access