Amazon Bedrock AgentCore: Heurist’s AI-native investment workbench with per-query USDC data

How Heurist Finance built an AI-native investment workbench on Amazon Bedrock AgentCore

A fragmented, expensive set of paywalled market-data sources is the default reality for anyone building modern investment workflows. Heurist turned that pile of vendors into a portfolio-aware chat experience by using Amazon Bedrock AgentCore and buying premium data per query, settling payments in USDC on the Base network. The result looks institutional but runs with a startup team.

Architecture at a glance

High-level flow: Anthropic Claude (via Amazon Bedrock) provides language reasoning → Strands orchestrates agent calls and services → Amazon Bedrock AgentCore supplies identity, memory, sandboxed code execution, guardrails, payments, and observability → AWS primitives (Aurora PostgreSQL, S3, CloudWatch, Secrets Manager) store state, artifacts, and traces.

That setup let Heurist concentrate on product differentiation, portfolio-aware workflows and research UX, while AgentCore and AWS handled identity, secure execution, payments orchestration, and tracing.

What Heurist Finance actually built

Heurist Finance is an AI-native investment workbench for retail investors that behaves like an institutional research platform. It aggregates market and alternative data, reads filings and news, supports deep research and portfolio construction, runs stress tests, and continuously monitors holdings, all within a portfolio-aware conversational interface.

Key components and providers:

  • Model: Anthropic Claude (via Amazon Bedrock)
  • Orchestration: Strands
  • Agent runtime & capabilities: Amazon Bedrock AgentCore (Identity, Memory, Code Interpreter, Observability, Guardrails, Payments)
  • Storage & infra: Amazon Aurora PostgreSQL (portfolio state), Amazon S3 (analysis artifacts), Amazon CloudWatch (traces), AWS Secrets Manager (runtime retrieval of payment credentials)
  • Payment settlement: USDC on the Base blockchain, with a CoinbaseCDP Payment Connector referenced as the signing connector

How per-query paid data works (the x402 flow)

Instead of negotiating long enterprise contracts with every data vendor, Heurist buys paywalled data on demand. The flow uses AgentCore payments and an x402 exchange: merchants return an HTTP 402 response with payment terms; AgentCore coordinates signing and proof; the merchant then returns the requested data. Heurist ties each paid request to the user identity, session state, and an isolated analysis sandbox so purchases and the resulting analysis are auditable.

Here’s the simplified sequence Heurist describes:

  1. Your product requests a paid data endpoint from a merchant.
  2. The merchant returns HTTP 402 with x402 payment terms (amount, recipient, asset = USDC, network = Base).
  3. AgentCore payments validates the x402 payload against the Payment Session’s maxSpendAmount. If the requested amount exceeds the cap, the user is notified and alternatives are suggested.
  4. If the price is within the cap, the product calls the Process Payment API. A Payment Instrument (an embedded wallet scoped to Base) signs the transaction; credentials are fetched at runtime from AWS Secrets Manager.
  5. The product retries the merchant call including payment proof in an X-PAYMENT header; the merchant returns the data on successful verification.

Example (illustrative) HTTP 402 response showing x402 payment terms:

HTTP/1.1 402 Payment Required
Content-Type: application/json

{
  "x402": {
    "amount": "50.00",           // USD equivalent or token units
    "asset": "USDC",
    "network": "Base",
    "recipient": "0xMerchantAddr",
    "memo": "data_access:earnings_note_2026-09"
  }
}

And a matching retry header (illustrative):

X-PAYMENT: eyJhbGciOiJ... (signed payment proof)

Note: Heurist frames x402 as an application-layer convention that uses HTTP 402 to encode payment terms for this per-query purchase flow rather than a formal IETF standard. The company implemented signing and processing through the AgentCore payments capability and a payment connector (referenced as the CoinbaseCDP Payment Connector).

Sandboxing, tracing, and operational controls

Two operational design decisions make the flow practical for a retail-facing finance product.

  • Isolated analysis sandbox: AgentCore’s Code Interpreter runs inside an isolated sandbox in the AWS environment with no arbitrary network egress. Analysis runs produce artifacts (charts, CSVs) saved to S3 and the sandbox tears down when the run finishes.
  • Traceable decisions and audit trails: AgentCore Observability captures user ID, workload identity, request ID, and trace ID. Those traces flow into Amazon CloudWatch so paid-data purchases, the resulting analysis, and decision traces are auditable and reproducible.

Runtime retrieval of payment credentials from AWS Secrets Manager limits long-lived exposure of signing keys and ensures the signing step is tightly scoped to the payment session.

Where AgentCore takes on the plumbing

Heurist reports that using Amazon Bedrock AgentCore let them avoid building the orchestration and infrastructure themselves. Heurist estimates roughly 80% less agent-system engineering versus building an in-house LLM orchestration stack. JW Wang, Founder of Heurist, said, “AgentCore does the platform work so we can double down our energy on the product work. The managed infrastructure saved us months.” The architecture delegates Identity, Memory, Guardrails, the Code Interpreter sandbox, payments orchestration, and Observability to AgentCore so Heurist could focus on portfolio-aware workflows and UX.

Practical reasons a product team would copy this pattern

  • Economics: Pay-per-query makes expensive, paywalled feeds usable without multi-year vendor contracts.
  • Speed: Reusing managed capabilities (AgentCore + AWS) reduces platform engineering effort and accelerates product iteration.
  • User safety: maxSpendAmount caps prevent runaway charges and the per-session model scopes financial risk.
  • Compliance posture: Auditable traces and sandboxed execution create a defensible path for recordkeeping and dispute investigation.

Trade-offs, risks, and concrete red flags

This approach is pragmatic, but it isn’t a drop-in solution for every team. Consider these operational and regulatory issues before you build:

  • Vendor adoption: Not all merchants will accept per-query crypto settlement or the x402 flow. Map vendor capability early.
  • Costs and variability: Per-query prices can fluctuate. Track average cost per paid-data query and variance, budget accordingly.
  • Settlement latency and reconciliation: On-chain settlement (USDC on Base) introduces confirmation latency and bookkeeping complexity. Reconciliation windows, gas/fee behavior, and custodial flows need explicit handling.
  • Regulatory and accounting questions: Crypto-settled vendor payments raise KYC/AML, VAT/sales tax, and revenue-recognition issues. Legal and finance review is mandatory, confirm how local regulators treat USDC payments and whether they’re treated as cash equivalents for accounting.
  • Disputes and refunds: The x402 flow doesn’t eliminate the need for a dispute-resolution process. Define operational playbooks for failed purchases, incomplete vendor delivery, and refunds.
  • Scalability and vendor rate limits: High query volumes may hit vendor-side limits or expose latency spikes. Pilot low-volume traffic patterns to surface those constraints.
  • Sandbox policy enforcement: The “no arbitrary network egress” property is enforced by the AgentCore runtime and underlying AWS network controls; include technical verification and periodic audits so compliance teams can validate enforcement.

Concrete pilot metrics and checklist

Before wide rollout, run a measured pilot and track these metrics:

  • Average and variance of cost per paid-data query (mean and standard deviation).
  • Median and 95th-percentile latency from initial merchant request to data availability after payment proof.
  • Dispute rate (failed purchases, incomplete data deliveries) and mean time to resolution.
  • Time-to-reconciliation between on-chain settlement events and accounting ledgers.

Finance & compliance checklist:

  • Confirm KYC/AML obligations for payees and any required counterparty screening.
  • Decide internal policy for crypto expense approval and budget controls tied to maxSpendAmount.
  • Get accounting sign-off on revenue recognition, tax treatment, and reconciliation cadence for USDC settlements.
  • Choose a custody model for payment instruments (custodial wallet vs. hosted connector) and document key rotation and secrets handling.
  • Define dispute/refund workflows and SLAs with merchants.

Roadmap signals and product gambles

Heurist plans to extend the same plumbing to event-driven research (e.g., earnings calendars), portfolio-aware market-event analysis, and recommendation signals based on peer behavior. Those features rely on persistent Identity and Memory to keep user context and on the payments flow to fetch occasional premium sources.

Strategically, the architecture is a bet that some vendors will embrace per-query settlement and that the business benefits of on-demand data outweigh the operational and regulatory friction introduced by crypto settlement. If vendor adoption lags or regulatory constraints tighten, negotiating traditional vendor contracts for high-volume feeds remains a fallback.

Practical decision rule

If most of your premium data usage is sporadic and unpredictable, and your finance/legal team is comfortable evaluating crypto settlement and reconciliation processes, pilot the per-query approach. If your product expects sustained, predictable high-volume access to the same datasets, you will probably get a better economic and compliance outcome from negotiated vendor contracts.

Key questions you might be asking, and honest answers

  • Can a small fintech buy paywalled data per query without enterprise contracts?

    Yes. Heurist uses Amazon Bedrock AgentCore payments and a payment connector to purchase premium data per query, settling in USDC on Base and tying purchases to user sessions via Identity and Observability.

  • How do they prevent runaway spending when buying data?

    Each Payment Session includes a maxSpendAmount. AgentCore payments compares vendor x402 terms to that cap and rejects offers above it, notifying the user and suggesting alternatives.

  • Is the analysis environment secure and auditable?

    AgentCore’s Code Interpreter runs in an isolated sandbox with no arbitrary network egress enforced by the AgentCore runtime and AWS network controls; Observability records user and trace IDs and exports traces to Amazon CloudWatch for audit and reproducibility.

  • Does this avoid building your own agent orchestration layer?

    Heurist estimates roughly 80% less agent-system engineering than building an in-house LLM orchestration stack, and JW Wang said the managed infrastructure “saved us months.” That’s an estimate from Heurist’s evaluation of the trade-off between building platform capabilities in-house versus using AgentCore and AWS.

Next practical steps if you’re considering the same approach

  • Prototype the payment UX and maxSpendAmount flow so you can observe how users react to per-query price prompts and rejections.
  • Map vendor capabilities early: which merchants accept x402-like offers and will settle on Base/USDC? Identify high-volume vendors for contract negotiation as a fallback.
  • Define trace retention and export policies for CloudWatch and S3 to satisfy compliance and incident review needs.
  • Work with finance and legal now: model settlement timing, fees, tax treatment, KYC/AML obligations, and reconciliation processes before pilot scale.
  • Run a low-volume pilot to surface latency, rate limits, dispute behavior, and accounting edge cases before committing to broad rollout.

“AgentCore does the platform work so we can double down our energy on the product work. The managed infrastructure saved us months.”, JW Wang, Founder of Heurist

The pattern is simple: outsource the plumbing that isn’t your core IP, identity, sandboxing, payments, traces, and focus engineering energy on the portfolio-aware research experience that differentiates your product. This doesn’t remove all operational burden, but it moves it into predictable, auditable channels where product, finance, and legal teams can measure and control risk.

0