What should an agent actually own?

Financial work has been automated for decades. Software calculates, processes documents, applies rules, and moves information between systems.

Agents introduce a different question.

We are encountering it while building agentic infrastructure for Revenue-Based Financing, where work moves among businesses, brokers, funders, financial information, underwriting systems, and approvals. Information arrives at different times. Conditions change. And the participant coordinating the work isn't necessarily the participant authorized to make the next decision.

In that environment, asking what AI can do isn't enough.

What should the agent actually be responsible for?

Performing a task is different from carrying responsibility

Software can perform a task without being responsible for what happens next.

Extract information. Calculate cash flow. Apply an eligibility rule. Route an application.

Responsibility looks different when an agent is given a bounded piece of work and expected to carry it toward an outcome. It may need to determine the next appropriate action, perform it, respond to what happens, and continue until the work is complete or another actor needs to take over.

That suggests a more useful definition of agent ownership:

An agent owns the work it has been given responsibility to carry.

Not permanent control of the entire process.

Being able to act doesn't mean having authority to act

Revenue-Based Financing makes this distinction difficult to ignore.

A broker may collect information, qualify a business, coordinate a financing request, and submit it to a funder. That doesn't give the broker the funder's underwriting authority.

The same distinction applies to an agent.

Capability asks: Can the agent do this?

Authority asks: May the agent do this?

An agent can have enough information to determine that an action is possible—and access to the tool capable of performing it—without having authority to take that action.

Production agent systems increasingly reflect this distinction through permissions, policies, approval requirements, action limits, and escalation boundaries. Capability operates inside an authority envelope.

In financial work, that matters because authority often belongs to an institution or person, not whichever system is technically capable of acting.

Not every task should belong to an agent

Some financial work is deterministic for a reason.

A calculation with a known formula doesn't become better because a model reasons about it. A hard policy rule may not need interpretation. Precisely specified operations may remain more predictable and auditable when conventional software performs them.

Other work depends on understanding changing circumstances and determining what should happen next. That is where agents become more useful.

And some work belongs to people because the relevant judgment, authority, accountability, exception, or relationship belongs to them.

The design problem isn't maximizing how much an agent performs.

It's assigning the work to the actor that should carry it.

During one financial process, that may be an agent, deterministic software, and a person at different moments.

The difficult part begins when the actor changes

Suppose an agent carries a piece of work until a decision requires human authority.

The person makes the decision.

What happens next?

If the work is going to continue, the person needs to understand what has already happened and why the decision reached them. When responsibility moves again, the next actor needs to know what changed and what remains unresolved.

A handoff isn't the movement of information. It is the movement of enough continuity for another actor to continue the work.

That can include current state, prior actions, decisions, unresolved work, relevant context, authority information, and the reason another actor became necessary.

In financial work, that actor may not even belong to the same organization.

The work can move among an agent, deterministic software, a broker, a funder, and back again.

Changing the actor shouldn't mean reconstructing the process.

The process has to outlive the actor

That raises a larger question:

Where does the process itself live?

Making one agent the permanent home of a long-running process is tempting, but current agent systems still face reliability problems as work becomes longer and conditions change. Errors can accumulate, assumptions can become stale, and agents can lose coherence or conclude that work is finished when it isn't.

Financial work can also pause while the world keeps changing. New banking information arrives. A funder requests something else. An offer expires. Another institution acts. A person intervenes.

Yet the process still needs to know where it stands.

That has led us to a principle:

The process belongs to the infrastructure. The task belongs to the actor.

This doesn't mean infrastructure acquires the authority of the institutions participating in the process. A funder's underwriting authority remains the funder's.

It means:

The continuity of the work should not depend on the continued presence of whichever actor is performing the current task.

What building in Revenue-Based Financing is teaching us

Revenue-Based financing makes these questions concrete.

Businesses, brokers, funders, financial-data providers, underwriting systems, payment systems, and other participants can touch the same financing process. Information arrives asynchronously. Financial conditions change. Authority is distributed. A financing request can progress, pause, redirect, resume, or end because of something another participant does.

That exposes something simpler agent examples can hide.

The goal isn't an agent capable of doing everything.

It's a process where each actor can perform the work it is responsible and authorized to perform—and another actor can continue when responsibility changes.

Responsibility has a boundary

As agents become more capable, deciding what they can do will become easier.

Deciding what they should own may become more important.

Give agents responsibility for work they are capable and authorized to carry. Use deterministic systems where certainty is preferable. Bring people in where their judgment, authority, accountability, or relationships are required.

But the thread connecting those actors cannot depend on any one of them.

The more capable agents become, the more important it becomes to know where their responsibility ends.