Picture this scene, which is becoming less hypothetical by the day: someone proudly shows you how their AI assistant "sorted out their finances." It reviewed their accounts, spotted a forgotten subscription, and suggested moving money into a deposit with a better rate. You ask how they connected the assistant to their bank. "I gave it my username and password," they say, as if it were the most normal thing in the world.

For that person, it's convenience. For anyone who has worked in banking, it's a nightmare shaped like a feature.

This week that scene stopped being hypothetical. The largest banks in the United States said, almost in unison, that they won't allow external AI agents to move money out of their customers' accounts. I think it's worth looking at this calmly, because behind the headline there is an architecture problem that is going to reach us in Chile, and fairly soon.

What happened

On October 13, during JPMorgan Chase's earnings presentation, Jamie Dimon was blunt: they won't let in "any outside agent" because it's too risky for customers and for the bank. "You don't want rogue agents, and there could be thousands of them," he said, according to CNBC. The bank clarified that it doesn't allow third parties to access accounts by obtaining the customer's credentials and logging in on their behalf, but that it does support authorized data sharing through open banking providers. In practice: an agent can see balances in read-only mode, but it can't transfer money or pay a bill, which is precisely what would make it useful.

Dimon added a sentence that, as an architect, I find the most important of the entire discussion: whoever uses these agents "should understand that there is a transfer of liability."

Over the following days the stance was repeated. According to PYMNTS, Citi, Bank of America and Charles Schwab fell into line: reading yes, moving money no. Schwab's CEO said they block unauthorized agents a double-digit number of times every week, Brian Moynihan (BofA) insisted on keeping a human in the loop to approve outflows of money, and William Demchak (PNC) was even more explicit: for this to happen, "laws about the transfer of liability will have to be passed," and it will have to be "with secure connections, authentication, and a human in the loop."

And today, October 22, Axios reported that banks are detecting and removing agents that are already operating inside customer accounts, some of them attempting actions the user never asked for. The most revealing detail was picked up by The Verge: a bank executive acknowledged that they struggle to tell agents apart, and to know whether an agent was authorized by the user or simply "got loose."

The problem isn't AI, it's delegation

It's easy to read this as banks defending their turf (and there is some of that: the same CNBC article mentions that JPMorgan is piloting its own assistant to move funds in search of better yield). But if we strip away the commercial layer, what remains is a question that banking systems never had to answer well: who is acting when a transaction is executed?

For decades the answer was binary. Either it was the customer, authenticated with something they know, have, or are; or it was the bank, acting on the customer's instruction. The entire security model (strong authentication, fraud monitoring, limits, even the attribution of liability) rests on that simplification.

An agent breaks that binary. It isn't the customer, but it acts as if it were. It isn't a regulated third party, but it makes decisions. And, unlike a traditional program, it doesn't fail deterministically: it fails probabilistically. When an agent uses the customer's credentials, to the bank it is indistinguishable from the customer. That is the core of the problem described by the executive in the Axios piece. It's not that AI is dangerous in the abstract; it's that the actor's identity disappears the moment someone hands over their password.

We already lived through a version of this with the screen scraping of financial aggregators, and it took the industry years to replace it with APIs built on explicit consent. With agents, the same shortcut is more tempting and considerably riskier, because now the one coming in doesn't just read: it decides.

What an architect should demand

If I take this out of the regulatory realm and bring it to the design table, I see five pieces that are not optional.

1. The agent's own identity. An agent should never operate with the user's credentials. It must have its own identity as a technical client, issued and verifiable, so that on every call the bank knows that the one acting is agent X from provider Y, on behalf of customer Z. Without this, everything else is cosmetic.

2. Scoped mandates, not broad permissions. Consent can't be "access to my account." It has to be a mandate with a shape: which operations, up to what amount, to which beneficiaries, for how long, with the possibility of immediate revocation. It's least privilege applied to an entity that, by design, will attempt things we didn't anticipate.

3. Tokens bound to their bearer. A stolen token should be useless outside the technical client it was issued to. The FAPI 2.0 profile requires exactly that: sender-constrained tokens via mTLS or DPoP, pushed authorization requests (PAR), and confidential clients only. These are not implementation details; they are the difference between an auditable agent and an impersonable one.

4. Human in the loop, proportional to risk. Not everything requires confirmation. Checking a balance shouldn't; emptying an account should. The architecture has to allow authentication step-up based on amount, destination, and behavior, returning the decision to the account holder when the agent steps outside its mandate. What can't happen is for human confirmation to become a rubber-stamp click that the agent itself learns to trigger.

5. Traceability of intent, not just of the transaction. When something goes wrong (and it will), the question will be who is liable. To answer it we need to record not only what was executed, but under which mandate, with which user instruction, and through which agent. That is the evidence that will make the "transfer of liability" Dimon talks about possible. Without a record, liability isn't transferred: it's diluted.

Seen as a flow, the difference between the shortcut and the right design looks like this:

sequenceDiagram participant U as Customer participant A as AI Agent participant P as Regulated provider (PSIP) participant B as Bank (account provider) U->>P: Grants scoped mandate (amount, destination, validity) P->>B: Authorization request (PAR + FAPI 2.0) B->>U: Authenticates the account holder and confirms consent B-->>P: Token bound to the technical client (mTLS / DPoP) A->>P: "Pay the electricity bill" P->>P: Is it within the mandate? P->>B: Payment order with token + mandate evidence B->>B: Risk assessment / step-up if applicable B-->>P: Traceable result P-->>A: Confirmation

The agent never touches the customer's credentials, nor does it talk directly to the bank with unlimited powers. It operates within a mandate that a regulated party manages and that the bank can verify.

And in Chile?

Here comes the part I find most interesting. Chile is building, right now, a good portion of that infrastructure.

The Open Finance System under the Fintec Law (Law 21.521) takes effect in July 2027. NCG 514, amended by NCG 569 in June of this year, defines payment initiation service providers (PSIP) as entities that can instruct payments and transfers on behalf of a customer, and requires prior, free, informed, express, and specific consent, stored on a durable medium together with the payment instruction data. It even establishes that "the person or computer system" interacting with the user cannot exert undue influence to force their consent. According to what the CMF presented and Chócale reported, the system's APIs will adopt FAPI 2.0.

And on October 1 the CMF launched ATENA, a sandbox for testing integrations against a Participants Directory with digital credentials, that is, the piece that establishes who is who in the ecosystem.

Verifiable participant identity, specific and traceable consent, a strong security profile. These are, almost one to one, the ingredients that US banks are missing this week.

What I'm not clear on (and I raise it as an open question) is how an autonomous agent will fit into that model. Will the agent be a PSIP? Will it operate through one? How do you express, in a "specific" consent, the instruction to a system that decides on its own when and how much to pay? I think the regulation leaves us well positioned for the conversation, but the conversation hasn't happened yet.

The opportunity of arriving later

The United States is facing this reactively: agents that are already inside, banks that block them, and a liability debate that, as Demchak said, will probably require new laws. Chile has something unusual in technology: the chance to arrive later, with the infrastructure under construction and the problem in plain sight.

If I had to propose something to an architecture committee today, it would be simple: let's treat agents as a type of participant from the design stage, not as an exception we block in production. Let them have identity, let them operate under mandates, let them leave evidence. And may the answer to "how did you connect your assistant to the bank?" never, under any circumstances, be "I gave it my password" again.

Trust in a bank was never based on nothing ever failing. It was based on always knowing who did what. Agents don't change that; they only force us to design it seriously.