u/usually_guilty99

I spent about eight years inside credit card authorization. eCommerce and not POS. Something about agentic checkout has been bothering me and I want to know whether anyone here has a better answer than I do.

Take the controls we actually run. Device fingerprinting. Behavioral biometrics, meaning mouse movement, typing cadence, how long someone sits on the CVV field (which always gets me and I have to yell out to my kids to give this to me quick). Velocity rules. 3DS step-up. One-time passcodes to a phone. Risk models trained on how real people move through a checkout.

Every one of those infers that a human is present and behaving normally. None of them verifies that the purchase was wanted.

That held for thirty years because a human was always eventually there. Even card-not-present, someone typed the number. Presence was a decent proxy for intent, so nobody had to separate the two.

Agentic checkout removes the human on purpose. The signals then go one of two ways. Some disappear, because there is no mouse movement and no hesitation to measure. The rest get emulated, and emulated cleanly, because an agent produces consistent timing and a stable device signature every single run. A model trained to catch the anomalous human has nothing to catch when there is no human and no anomaly. A compromised agent looks the same as a working one.

I have been calling this the presence assumption. Authenticating the human, treated as though it authorized the transaction.

What I cannot resolve is what carries the decision once presence is gone. Options I keep seeing, and my problem with each:

• Agent identity and attestation. Tells you which agent is calling. Says nothing about whether this purchase sits inside what the person asked for.
• Merchant-side allowlists. Do not travel, and agents shop across merchants.
• Spend caps at the card. Blunt, and they do not survive an agent splitting a purchase.
• Post-hoc dispute. Fine on cards. Useless when the action does not reverse.

Real question, not rhetorical. For anyone running fraud ops or building on the agent payment rails, what are you planning to lean on is the absence of presence? Is anyone checking the transaction against the mandate the human actually granted, and does that hold up operationally? This becomes a huge liability in itself. I am sure there are solutions out there, at least in parts. Please illuminate.

>

[ Removed by Reddit on account of violating the content policy. ]

 We are working on a reliability scanner and Supabase was one of few opesource codebase we picked from GitHub. The idea was fairly simple, how stable is the code, what are the critical problem areas (if any) and what is the Production Reliability Score (PRI) for Supabase. 

Interesting finding, a surprising number of identified problems were already reported by the community and fixed. Speaks volumes about the quality of Supabase. 

But the problems clustered around cron jobs, scheduled webhooks and queues stood out as potential key problem areas:

A few examples:

• Editing a cron job could corrupt HTTP headers containing a comma or parenthesis (#46829).
• A backslash in a value could cause the webhook to fire without its body or headers (#45674).
• Queue messages sharing the same timestamp could disappear from the message list (#47015).

The silent failures concerned me. The job can report success while the receiving system gets incomplete or corrupted data.

The header problem also required three separate fixes over roughly three months. Two fixes passed review and were merged, but the problem returned with different real-world inputs. CodeRabbit approved these PRs. 

For a production sensitive product, I believe that there is some amount of fragility in the code where normal code review and test coverage seems to be failing. 

Have cron jobs, scheduled webhooks or queues been a problem area for you? Or is this just a corner case(s)? 

I do have 55 other issues detected that do not have a GitHub ticket filed as yet and your response will help me better assess the new issues. Thank you. 

 We are working on a reliability scanner and Supabase was one of few opesource codebase we picked from GitHub. The idea was fairly simple, how stable is the code, what are the critical problem areas (if any) and what is the Production Reliability Score (PRI) for Supabase. 

Interesting finding, a surprising number of identified problems were already reported by the community and fixed. Speaks volumes about the quality of Supabase. 

But the problems clustered around cron jobs, scheduled webhooks and queues stood out as potential key problem areas:

A few examples:

• Editing a cron job could corrupt HTTP headers containing a comma or parenthesis (#46829).
• A backslash in a value could cause the webhook to fire without its body or headers (#45674).
• Queue messages sharing the same timestamp could disappear from the message list (#47015).

The silent failures concerned me. The job can report success while the receiving system gets incomplete or corrupted data.

The header problem also required three separate fixes over roughly three months. Two fixes passed review and were merged, but the problem returned with different real-world inputs. CodeRabbit approved these PRs. 

For a production sensitive product, I believe that there is some amount of fragility in the code where normal code review and test coverage seems to be failing. 

Have cron jobs, scheduled webhooks or queues been a problem area for you? Or is this just a corner case(s)? 

I do have 55 other issues detected that do not have a GitHub ticket filed as yet and your response will help me better assess the new issues. Thank you. 

 We are working on a reliability scanner and Supabase was one of few opesource codebase we picked from GitHub. The idea was fairly simple, how stable is the code, what are the critical problem areas (if any) and what is the Production Reliability Score (PRI) for Supabase. 

Interesting finding, a surprising number of identified problems were already reported by the community and fixed. Speaks volumes about the quality of Supabase. 

But the problems clustered around cron jobs, scheduled webhooks and queues stood out as potential key problem areas:

A few examples:

• Editing a cron job could corrupt HTTP headers containing a comma or parenthesis (#46829).
• A backslash in a value could cause the webhook to fire without its body or headers (#45674).
• Queue messages sharing the same timestamp could disappear from the message list (#47015).

The silent failures concerned me. The job can report success while the receiving system gets incomplete or corrupted data.

The header problem also required three separate fixes over roughly three months. Two fixes passed review and were merged, but the problem returned with different real-world inputs. CodeRabbit approved these PRs. 

For a production sensitive product, I believe that there is some amount of fragility in the code where normal code review and test coverage seems to be failing. 

Have cron jobs, scheduled webhooks or queues been a problem area for you? Or is this just a corner case(s)? 

I do have 55 other issues detected that do not have a GitHub ticket filed as yet and your response will help me better assess the new issues. Thank you. 

I held a static analysis run against Supabase's own issue history to see if it was finding real things

I've been testing a reliability scanner and wanted to know whether its findings were noise or not. So instead of trusting the tool, I took one run against the Supabase codebase at v1.26.07 and checked every finding against the project's actual filed GitHub issues. Not "does this look like a bug," but "did a real user already report this."

The part I didn't expect: the maintainers come out looking good. Of the findings that matched a filed issue, 71% had already been resolved, 80 of them through merged PRs. This is a well-maintained project. That's not the interesting part though.

The interesting part was where the matches clustered. Cron. Editing a scheduled job corrupted any HTTP header containing a comma or a parenthesis (#46829). A backslash in a value dropped the body and headers entirely and the webhook fired empty (#45674). The queue message list silently hid messages that shared a timestamp (#47015). None of these throw an error. The job reports success and the receiving end gets garbage.

What stuck with me: the header-corruption one took three separate merged fixes across three months before it held. Two fixes shipped, passed review, and didn't survive real input. That's not a careless team, it's a genuinely fragile corner of the product.

So the question for people who actually run this in prod: does that match your experience? Is the cron / scheduled-jobs / queue area the part you've had to be careful around, or did I just happen to scan a version where that was noisy? Genuinely curious whether the pattern holds or whether it's an artifact of one snapshot.

Governance has always recorded what happened. Agents made recording too late. The distance between a system that records an action and a system that authorizes it before it executes is the architectural fact the next decade of governance has to address.


https://fixgovernance.ai/essays/the-authorization-gap

I held a static analysis run against Supabase's own issue history to see if it was finding real things

I've been testing a reliability scanner and wanted to know whether its findings were noise or not. So instead of trusting the tool, I took one run against the Supabase codebase at v1.26.07 and checked every finding against the project's actual filed GitHub issues. Not "does this look like a bug," but "did a real user already report this."

The part I didn't expect: the maintainers come out looking good. Of the findings that matched a filed issue, 71% had already been resolved, 80 of them through merged PRs. This is a well-maintained project. That's not the interesting part though.

The interesting part was where the matches clustered. Cron. Editing a scheduled job corrupted any HTTP header containing a comma or a parenthesis (#46829). A backslash in a value dropped the body and headers entirely and the webhook fired empty (#45674). The queue message list silently hid messages that shared a timestamp (#47015). None of these throw an error. The job reports success and the receiving end gets garbage.

What stuck with me: the header-corruption one took three separate merged fixes across three months before it held. Two fixes shipped, passed review, and didn't survive real input. That's not a careless team, it's a genuinely fragile corner of the product.

So the question for people who actually run this in prod: does that match your experience? Is the cron / scheduled-jobs / queue area the part you've had to be careful around, or did I just happen to scan a version where that was noisy? Genuinely curious whether the pattern holds or whether it's an artifact of one snapshot.

Educational research only. Not investment, financial, legal, or tax advice.

S&P 500 Market Weather Research (weekly)

Date	Signal	Score	Risk	Support	Appetite	Pressure
2026-07-28	Bullish	57/100	Low	3/100	4/100	15/100
2026-07-29	Bullish	57/100	Low	3/100	4/100	17/100
2026-07-30	Bullish	57/100	Low	3/100	4/100	19/100
2026-07-31	Neutral	52/100	Medium	3/100	4/100	22/100
2026-08-01	Bullish	57/100	Low	3/100	4/100	9/100
2026-08-02	Bullish	57/100	Low	3/100	4/100	12/100
2026-08-03	Bullish	66/100	Low	15/100	4/100	12/100

Deterministic Evidence Snapshot

• Saturn Sign Cycle: Saturn in Pisces is scored as a 5.0 structural risk cycle for S&P 500.
• Rahu Volatility Cycle: Rahu in Aquarius adds 2.0 volatility pressure for S&P 500.
• Mars Momentum Risk: Mars in Taurus contributes 2.0 short-fuse momentum risk for S&P 500.
• Lunar Phase Risk: Moon is 12.38 degrees from full moon phase.

Method: deterministic Vedic market-cycle calculations. This post includes only market-weather fields and excludes private user/profile data.

Track forward outcomes separately before changing any model weights.

Hi guys, this may have been asked and answered. Apologies in advance.

I have not gone back to India for a while. I do not have a Bank account in India. I would like to sell my parents property and move the funds to the US. I was told NRO => NRI => US Account would be the best process (per Reddit)

I was wondering - If I require anything like PAN card and Form 97 to open a bank account. I would rather avoid it, how to go about this process. Please advise.

I do have a OCI card.

Working on a runtime authorization layer for cross-system agent actions. The core decision is per action: an actor wants to run an operation on a target, and something or someone has to decide allow / deny / escalate before it executes.

The obvious governance instinct is to route uncertain or high-impact actions to a human. We started there. Then we watched what a review queue does under real agent volume. Every action lands in front of a person, the person can't actually evaluate each one, and they start clicking approve to keep the pipeline moving. At that point the queue still looks like oversight in the audit log but it has stopped being oversight in fact.

So we flipped the default. The system returns an automated verdict against live policy and current state, and a human is pulled in only on genuine uncertainty, mostly a low-confidence identity match where guessing is the real risk. Escalation is the exception path rather than the default gate.

The part I keep turning over: this means most agent actions never see a human, by design. I think that's more honest than a rubber stamp. I also know how it reads to a compliance owner who wants a person in the loop on paper.

Where I want the room to push: is "automated by default, human on genuine uncertainty" a defensible governance posture, or is there a class of action where a human gate is non-negotiable even knowing it degrades to rubber-stamping under load? And if the latter, how do you draw that line without it quietly expanding to cover everything?

Your opinion matters, where do you draw that line?

Compliance officers of this sub, real question about how you're handling the classify-once problem for AI systems.

You mark a use case high-risk in March. In June the model gets retrained on newer data. In August the deployment scope shifts to a new geography. In October the auditor arrives and asks for evidence. The evidence they get is the March record.

The GRC tools I've seen all mechanize the March record faster. None of them addresses that the March record has drifted by August. Article 26 deployer obligations describe an operating state that has to be maintained continuously, not a filing that gets updated on some cadence.

What's actually working in your programs? Are you making the operating systems produce compliance evidence at the moment decisions happen, or is a person still chasing it after the fact? And how are you handling the retraining event specifically, that's the one that always breaks the inventory model.

Wrote about the shape of this here: https://fixgovernance.ai/essays/compliance-is-not-an-inventory

Anthropic proposed a Cyber Jailbreak Severity framework for Fable this week, scoring jailbreaks by capability gain and how easily they're found. Genuine step, and it walks up to a trap this field fell into once already.

Governance spent a decade producing scores that sat next to the workflow instead of inside it. A severity framework is better, because it's meant to feed a control. That's also where the risk starts.

A score is an assessment. A control is a decision in the execution path. They get conflated the moment a severity tier hardens into a single configurable threshold that decides what ships. Once that threshold exists and is observable, it's a target. A competent adversary probes until they find its edge and tunes attacks to land just under it. A boundary you can publish is a boundary someone can walk around.

CVSS survived being public because a software vuln is a fixed artifact. A jailbreak against a deployed agent isn't fixed. It moves the instant you describe how you're measuring it.

Agents make it sharper. The same jailbreak tier is a non-event against a read-only agent and a breach against one wired into payment rails or identity. Severity is coupled to what the agent is authorized to do once the prompt gets through. So the operative boundary can't live where the model lives. It has to live at the authorization layer: a decision per action, revocable, versioned, that never trusted the model in the first place.

For a 1.0 the rule is clean: keep the severity scale public as shared language, treat any deployed threshold as an operational secret, and put the real containment at execution. No serious buyer should put a frontier model into production on the strength of a severity threshold alone.

Curious where people here land on the assessment-versus-control line, especially for agents with write access to systems that matter.

First comment: Long version: fixgovernance.ai/essays/the-legible-boundary. No signup, no pitch.

Watching the Fable 5 saga, one detail stuck with me. What changed between the version that got pulled and the one coming back isn't the model, it's a classifier at the output boundary that decides per request whether to answer or fall back. Same weights, different gate.

Which made me realize the governance asymmetry in my own pipeline. The generation step now has a per-request gate. The merge step, where that generated code actually enters production, has a human skim and a green CI run. CI tells me the code passes tests. It doesn't tell me the blast radius, whether this path has a history of incidents, or whether it touches a regulated service.

For teams shipping meaningful volumes of AI-generated code: are you doing anything structured at the merge boundary specifically, or is it still tests-plus-review like everything else? Curious whether anyone's scoring PRs on anything beyond test pass/fail before they land.

Watching the Fable 5 saga, one detail stuck with me. What changed between the version that got pulled and the one coming back isn't the model, it's a classifier at the output boundary that decides per request whether to answer or fall back. Same weights, different gate.

Which made me realize the governance asymmetry in my own pipeline. The generation step now has a per-request gate. The merge step, where that generated code actually enters production, has a human skim and a green CI run. CI tells me the code passes tests. It doesn't tell me the blast radius, whether this path has a history of incidents, or whether it touches a regulated service.

For teams shipping meaningful volumes of AI-generated code: are you doing anything structured at the merge boundary specifically, or is it still tests-plus-review like everything else? Curious whether anyone's scoring PRs on anything beyond test pass/fail before they land.

Watching the Fable 5 saga, one detail stuck with me. What changed between the version that got pulled and the one coming back isn't the model, it's a classifier at the output boundary that decides per request whether to answer or fall back. Same weights, different gate.

Which made me realize the governance asymmetry in my own pipeline. The generation step now has a per-request gate. The merge step, where that generated code actually enters production, has a human skim and a green CI run. CI tells me the code passes tests. It doesn't tell me the blast radius, whether this path has a history of incidents, or whether it touches a regulated service.

For teams shipping meaningful volumes of AI-generated code: are you doing anything structured at the merge boundary specifically, or is it still tests-plus-review like everything else? Curious whether anyone's scoring PRs on anything beyond test pass/fail before they land.

Every regulated team I talk to still points to the same control when something ships wrong: a human approved it. There's a name in the approval field. Someone signed.

Look closer at what that signature now means. An agent generates the change. The diff is large, fast, and one of dozens that day. A reviewer clicks approve. The name gets recorded. But the thing that signature used to certify, that a human read this, understood it, and stands behind it, didn't happen. It couldn't have. Nobody absorbs thousands of lines of agent output at agent cadence. The approval is collected. The reading behind it is gone.

That's the gap, and it's worth being precise about. This is not a slowness problem you fix by adding reviewers or helping them read faster. Accountability used to be a real artifact: a person who could answer "why did this ship" because they actually decided it. At agent velocity that artifact quietly stopped existing, even though the approval field is still populated. The signature outlived the thing it was signing.

Which makes the populated field worse than an empty one. An empty one tells the truth: nobody vetted this. A signed one manufactures accountability that isn't there, and an examiner or an incident review will eventually pull that thread and find nothing behind the name.

The fix isn't a faster human. It's producing the artifact the human used to be: a durable, independent record of what was actually checked, by what, against what, so accountability attaches to something real instead of a click. A signature has to point at evidence, not at a person who couldn't have read what they signed.

So the question for anyone running AI-assisted delivery in a regulated environment: when the wrong thing ships, and it will, what does your approval record actually prove? A decision, or a keystroke?

Mapping an initiative to the EU AI Act, NIST RMF, and ISO 42001 is real work and worth doing. But a framework you fill in is a snapshot, and governance risk isn't a snapshot problem. The score you record in January describes a system that no longer exists in February, the moment the model is retrained, the owner leaves, the policy is reworded, or the data scope expands. Nothing in the checklist tells you it went stale. You end up defending a green tier against a system it stopped describing.

The harder questions sit in the gaps the standards can't see. Is this approval still valid today, or just stored? Is this agent acting on the right entity, or one the policy technically allows but the source event never referred to? What governs the change between two audits?

Governance has to resolve to a decision at two control points, computed live. The merge gate, where AI-generated code lands before it ships. And the agent runtime, where an agent executes an action. At both the question is the same: should this proceed, against the current state of the system it is about to touch. Not should it have proceeded last quarter.

I've been working this out in the open at fixgovernance.ai.

About twenty essays so far, no signup, no pitch. If you're coming at it from the standards side, I'd be glad to compare where the checklist ends and the runtime decision has to begin.

A governance score you store is a fact about the past. The only score that counts is the one you can recompute right now.