Orchestrator and subagents inside the customer's walls
· 4 min read
Once discovery produces a workflow and a phase plan, the next question is where everything runs. On every engagement I led, I also acted as the solution architect for the deployment. A production agent often runs inside the customer's network, under an identity they manage, and works with systems of record their auditors review.
My aim was to fit the agents into that environment so the customer could see exactly what each agent did, and the engineering team had the guardrails and audit trails it needed to inspect and fix anything quickly.
Inside the customer's network, the orchestrator reads signed-off limits from config, hands each step to a subagent, and sends anything unusual to a queue. Every step lands in the audit trail.
1. Run where the data lives
Where an agent runs depends on the process and on the customer's governance. Banks and credit unions usually prefer that customer data stays inside their network, so the orchestrator and its subagents run on machines the customer controls, and the build and configuration are delivered to those machines. When the data is critical and the automation has to run without interruption or anyone watching over it, it gets its own Windows VM. That keeps the conversation with their security team simple from day one.
2. Give each agent its own identity
An unattended agent like that also gets its own service account in the customer's directory, with role-based access to only the screens and records its workflow needs. When someone asks "what can this agent touch?", the answer is a short, clear list.
Least privilege also shapes the product. At one customer, the security team asked for the agent to run without admin rights. I changed the agent to work that way, and the change shipped to every customer after that. A good request from one customer improved the product for everyone.
3. Split the work between the orchestrator and subagents
The orchestrator owns the schedule, the order of steps, the routing and the limits. Each subagent owns one job, such as checking an item, updating a record or writing a report. Keeping that split clean makes each subagent easy to test on its own and easy to replace later, and it means every step leaves its own entry in the audit trail.
SUBAGENTS = {
"validate": validate_item,
"decide": decide_item,
"post": post_to_core_system,
}
def orchestrate(items, policy, audit):
for item in items:
for step in policy["steps"]: # the order comes from config
result = SUBAGENTS[step](item, policy)
audit.write(item.id, step, result) # every step leaves a trail
if result.route != "continue":
break # human queue, manual review or exception
4. Choose screens or APIs per system
I've automated work inside SAP, Salesforce, ServiceNow, and core banking platforms such as Jack Henry SilverLake and Fiserv Premier. Most of that work ran through the same screens people use. When an approved API is available, I prefer it.
- Screens: works with what the customer already has. Needs reliable selectors, a check after every step, and a plan for system upgrades.
- API: fast, stable and easy to test. Needs approval, credentials and sometimes a license.
5. Bring outside models in carefully
When a subagent calls an LLM, I treat it like any other outside vendor: a provider the customer has approved, only the fields the step needs, and the request and response kept in the audit trail next to the item. Standards like the Model Context Protocol help by making the list of tools an agent can call explicit and easy to review.
6. Keep governance in config
Limits and routing rules change more often than the agents do, and customers like being able to read them. So they live in config the customer reviews and signs off, and the orchestrator reads it at the start of every run. At a regional bank, raising the per-check auto-approval limit for mobile deposits from $5,000 to $25,000 was a config change the bank signed off on. The workflow itself didn't change.
# policy.yaml (simplified), signed off by the customer
workflow: mobile_deposit_decisioning
steps: [validate, decide, post]
auto_limit: 25000 # raised from 5000 after sign-off
routes:
over_limit: human_review
validation_error: exception_queue
- At a regional bank, one underwriting workflow ran end to end across 5 systems, bringing 6 risk inputs together for each decision, 12 hours a day on weekdays.
- When a customer's security team asked for the agent to run without admin rights, the change I made shipped to every customer.
Other ways teams approach this
Every company handles this differently, and there's no one right answer. Some teams run agents in their own cloud and connect to customer systems over APIs, others deploy inside the customer's network, and many mix the two depending on the data. Common threads: agents get only the permissions their task needs, limits are written down, and someone monitors the results. Whichever model you choose, keeping identity, limits and audit trails easy to inspect helps both the customer and the engineering team.
A checklist before go-live
- Where the agents run fits the process and the customer's governance, with a dedicated Windows VM for critical, unattended work.
- Each unattended agent has its own service account with only the access it needs.
- Each system is reached through an approved API or a tested screen path.
- LLM calls go to an approved provider with only the needed fields, and are kept in the audit trail.
- Limits and routing live in config the customer has signed off.