Enterprise AI Agent Development: Lessons from Production Deployments

ibm,_the_zig,_augmented_ai_labs · Consulting · year n/a · source Agentic: yes · promotional bias: low · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Enterprise AI agent production deployment

The panel discusses why enterprise AI agents are difficult to deploy in production: cost surprises, risk tolerance, evaluation uncertainty, human oversight, security, agent communication, tool maturity, and context-window cost all become practical blockers.

Constraints:

Clients may want impressive demos while production risk tolerance remains low.
Costs can grow unexpectedly when prototype agents scale.
Financial services and legal customers require conservative human-in-the-loop designs.
Agent-to-agent protocols and tooling are still evolving.
Longer context windows can help but also increase token and inference cost.

Architecture

The panel recommends conservative enterprise-agent architecture: scoped use cases, evaluation around business outcomes and guardrails, human-in-the-loop decision points, least-access security, anonymization/encryption where needed, and emerging communication protocols such as ACP/A2A for agents or services that need to interoperate across frameworks.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  scoped-use-case["Scoped use case"] --> evaluation-layer["Evaluation layer"]
  evaluation-layer --> human-in-loop-dashboard["Human-in-loop dashboard"]
  human-in-loop-dashboard --> agent-runtime["Agent runtime"]
  agent-runtime --> security-controls["Security controls"]
  security-controls --> agent-runtime
  agent-runtime --> agent-communication-protocol["Agent communication protocol"]

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Scoped use case`	Defines the specific enterprise problem and acceptable risk level before scaling.	`Evaluation layer`
`Evaluation layer`	Measures opex reduction, guardrail compliance, and readiness for production.	`Human-in-loop dashboard`
`Human-in-loop dashboard`	Catches uncertainties and lets people make decisions where stakes or costs justify it.	`Agent runtime`
`Agent runtime`	Runs enterprise agent workflows, function calls, and tool interactions.	`Security controls`, `Agent communication protocol`
`Security controls`	Applies least access, encryption, anonymization, and limiting of model pipes for sensitive data.	`Agent runtime`
`Agent communication protocol`	Enables agents, microservices, or subprocesses to communicate across frameworks.	—

Data flow

Enterprise teams start with scoped agent use cases, evaluate whether the system reduces opex while respecting guardrails, route uncertain or costly decisions to humans, restrict model and tool access by least privilege, and connect agent services through protocols when cross-system communication is needed.

“we almost always have elements of a human in the loop during the process.”transcript, stated

“MCP deals mostly with model context. So it provides tools, resources or prompts to the model specifically or to an LLM specifically really.”transcript, stated

Why this architecture

The panel favors conservative, human-supervised, evaluated deployments because enterprise agents can look impressive in demos while production risk, cost, and tool/security maturity remain hard to manage.

“sometimes the challenge is the level of risk that the client actually wants to take when things get put into prod”transcript, stated

“when we started increasing scale that's when I think there were a lot of surprises.”transcript, stated

Models used: LLMs · MCP · A2A · ACP · Autogen

Scale

The panel cites financial services and law firms as conservative customer contexts.
“given the kind of customers that we're dealing with a lot of financial services, law firms”transcript, stated
The email-agent anecdote produced about $700 of attorney time before a human-in-loop correction.
“it was costing her like $700 in the attorney's time.”transcript, stated

Alternatives considered (roads not taken)

Scale a prototype by throwing every technique at the problem.

Rejected because: The panel says unspecific overbuilding led to surprising bills.

“we would throw the kitchen sink at certain parts and not be very very specific about the problems that we were solving.”transcript, stated

Run costly decisions without human review.

Rejected because: The panel's email-agent anecdote shows autonomous loops can create real external costs.

“I will always put human in the loop uh as long as the decision will cost more than the inference.”transcript, stated

Use MCP for all agent-to-agent communication.

Rejected because: The speaker distinguishes MCP's model-context role from ACP/A2A horizontal service communication.

“whereas A2A or ACP work more on this horizontal level where they enable uh an agent or a micros service or subprocess to communicate”transcript, stated

Patterns

`human-in-the-loop-gate` (governance)

The panel recommends human review for enterprise agent decisions, especially when the decision cost or risk exceeds inference cost.

“there's dashboards that are really really specific about where things are being caught and uncertainties that are happening within the process”transcript, stated

`eval-driven-development` (evaluation)

The panel evaluates agents against opex reduction and guardrail behavior rather than demo impressiveness.

“if we'd like to reduce opex, that's what we're evaluating for mostly. Uh, we're also definitely taking into consideration guard rails.”transcript, stated

`privacy-preserving-processing` (governance)

The panel maps enterprise agent access to human-style least-access controls plus encryption and anonymization.

“You use least access principles. you use like the same things you would for a human admin would for engineers, right? Um you encrypt things when you need to. You anonymize things”transcript, stated

Tradeoffs

Use conservative human-in-loop deployment.

Chose Dashboards and human decision points. over Fully autonomous production decisions..

Rationale: The customers discussed include financial services and law firms where risk tolerance is low.

“we're pretty conservative about the way that we approach it given the kind of customers that we're dealing with”transcript, stated

Scope enterprise agent problems narrowly.

Chose Specific problems and cost-managed designs. over Throwing the kitchen sink at each part..

Rationale: The panel connects broad unspecific designs to surprise bills.

“not be very very specific about the problems that we were solving. And then all of a sudden the bill was coming”transcript, stated

Use ACP/A2A for horizontal communication.

Chose Agent/service communication protocols across frameworks. over Relying on MCP alone for inter-agent communication..

Rationale: The speaker says MCP is mainly model context, while ACP/A2A connect agents or subprocesses horizontally.

“A2A or ACP work more on this horizontal level where they enable uh an agent or a micros service or subprocess to communicate with another”transcript, stated

Gotchas (what bit them)

Cost surprises appear only after scale increases.

Root cause: Prototype testing can hide the cost of broad agent use and oversized context/tool use.

Resolution: Scope problems tightly and manage cost as an explicit production metric.

“it was one thing to be at a smaller scale and testing things out and it was working and it was secure but when we started increasing scale”transcript, stated

Autonomous loops can create external costs.

Root cause: An agent that interacts with third parties can keep working without human oversight.

Resolution: Insert human review when the possible decision cost exceeds inference cost.

“she realized that the agent was going back and forth with her attorney. Um, and it was costing her”transcript, stated

Longer context windows can backfire economically.

Root cause: More context can increase token and inference cost in enterprise settings.

Resolution: Use context-window expansion selectively rather than assuming bigger context is always better.

“the longer context windows it's it it's funny that you mentioned that because to one to one degree like it's helpful but to another degree it makes things more expensive.”transcript, stated

Evaluation

The panel recommends evaluating enterprise agents against operational cost reduction, guardrail behavior, uncertainty capture, and human decision readiness.

Metrics: Opex reduction · Guardrail compliance · Uncertainty capture · Human decision points · Inference/token cost