Hindsight Made a Repeated Stripe Timeout Easier to Investigate

The second Stripe timeout should not have to start from zero.

Store B's payment is stuck in an uncertain state, and the incident fields tell us the processor, error, merchant, and amount. They do not tell us that Store A recently saw a similar timeout or that the earlier investigation ended with a successful route through another processor.

That missing experience is the small, concrete problem behind PaymentOps Memory Agent.

I built this prototype to make one difference visible: an investigation using only the current incident versus one that can retrieve a resolved incident from persistent memory.

It is intentionally a narrow demonstration. The payment data is synthetic, the app does not connect to a processor, and its default response wording is deterministic. Those constraints make the memory behavior easier to inspect without implying that an operational payment system exists behind the screen.

The Stateless Starting Point

A stateless assistant can still be useful.

Given:

Store B, Stripe, timeout, INR 3,800

it can recommend checking processor status and request logs, and reconciling the original attempt before retrying. That is reasonable generic advice.

But if an earlier team investigation found a relevant pattern, the new response has no way to know it unless the operator pastes that history into the prompt again.

Repeated investigation is not only an inconvenience. It makes operational knowledge hard to reuse, especially when the useful detail is an outcome rather than a static document:

this processor reported a timeout, we checked the original attempt, and routing through a different processor succeeded.

A prompt can contain that information, but a stateless workflow does not preserve it from one incident to the next.

A Small Architecture With an Inspectable Boundary

The app uses FastAPI for three narrow operations: serve the interface, retain a resolved incident, and analyze an incident either without memory or with memory.

A plain HTML, CSS, and JavaScript page gives the operator two distinct analysis actions and a separate previous-incident form. The current incident is never sent to a payment processor.

The memory-aware path calls Hindsight's Python client.

The retained experience goes to a Hindsight bank named paymentops-demo. Later, the app sends a query about the current processor and error to that bank's recall operation.

It displays the returned evidence beside the response so a reviewer can see what the agent actually received.

The baseline route does not call Hindsight at all.

This matters for the comparison: the "without memory" response is not a memory result that has been hidden from view. It follows a separate code path and is explicitly marked as not having queried Hindsight.

Hyperswitch informed the domain vocabulary of processors and alternate routing, but I did not run the payment switch or copy its implementation.

The Hyperswitch project is a full payment orchestration platform; this prototype represents only synthetic payment events.

I evaluated RocketRide as a possible workflow runtime, but its server and pipeline deployment would add another service to this narrow flow.

HydraDB was evaluated as a potential relationship/graph layer, but was kept outside the minimal prototype scope.

How Hindsight Fits

Hindsight is the central memory component, not a local Python collection or a file pretending to be memory.

Its official client sends retain and recall requests to the Hindsight API. Hindsight owns the persistent bank and its retrieval index. The app itself does not persist incident experiences.

To keep the first local run free of provider credentials, the included PowerShell launcher uses Hindsight's none LLM provider and chunks retain mode.

This stores the submitted text as memory without LLM extraction. Hindsight uses its ONNX embedding provider for retrieval, while an RRF-only ranking path avoids requiring another reranker service or model.

This is genuine Hindsight persistence and recall, but it is a deliberately reduced configuration: it does not extract structured facts, consolidate observations, or call Hindsight's reflect operation.

Retain sends a plain text experience with the merchant, processor, error, amount, and resolution.

Recall asks for prior payment experiences matching the processor and error.

Once Hindsight returns evidence, the app uses that returned payload to select the memory-aware guidance.

If Hindsight has no matching result, the app says so and keeps the advice generic. It does not invent a past incident.

The Before and After

Before retaining Store A, the operator submits Store B and selects Analyze without memory.

The response calls out general timeout checks and the risk of retrying before the original attempt is reconciled. No memory query occurs.

Next, the operator records Store A's resolved incident.

The app sends the experience to Hindsight and displays the submitted text.

Selecting Analyze with Hindsight performs a fresh recall request.

In the demonstrated case, Hindsight returns the prior Stripe timeout and its alternate-processor resolution.

The guidance can then recommend comparing current processor behavior with that prior case and investigating processor-specific timeout behavior before retrying through the same processor.

That recalled event is evidence, not a rule to automatically route a payment.

Store A and Store B may differ in payment method, time, configuration, and final state. The response says to verify the current attempt and leaves the decision with the operator.

Memory changes the investigation context; it does not authorize a transaction.

A Few Lines That Matter

The baseline is intentionally plain:

python
def generic_guidance(incident: Incident) -> str:
    return (
        f"A {incident.error} was reported by {incident.processor} for {incident.merchant}. "
        "Check the processor status and request logs, verify whether the payment reached a "
        "terminal state, and avoid an immediate duplicate retry until the original attempt "
        "is reconciled. No prior incident was consulted for this analysis."
    )