Agent-to-Agent Calling in Amazon Connect Workspace

Most contact centers treat internal collaboration as a “nice to have.” Then peak season hits—holiday delivery exceptions, supplier delays, inventory disputes—and agents spend more time hunting for help than solving the customer’s problem.

Agent-to-agent calling inside Amazon Connect agent workspace fixes a surprisingly expensive bottleneck: the dead time between “I need an expert” and “I found them.” And if your broader strategy includes AI in customer service, this is one of the best foundational moves you can make—because AI can’t accelerate handoffs that don’t exist.

This post breaks down a practical, extensible way to enable agent-to-agent calling as a third-party (3P) app in Amazon Connect, then shows how to connect it to the bigger story we’re exploring in this series: AI in Supply Chain & Procurement. If you support order management, supplier inquiries, returns, or logistics escalation, internal calling is the plumbing that makes AI-driven operations actually work.

Why internal calling belongs in your AI strategy (and supply chain ops)

Internal calling is the difference between “we have AI” and “we run an AI-assisted operation.” The point isn’t that agents can talk to each other—teams already do that in chat tools. The point is context + speed + auditability inside the same system where customer interactions are managed.

Here’s what changes when agent-to-agent calling lives in the agent desktop:

• Faster exception resolution: A late shipment isn’t a generic case. It’s carrier performance, warehouse constraints, and promised delivery dates. Getting the right person live reduces repeat contacts.
• Cleaner handoffs for AI tools: When AI generates suggested actions, summaries, or next steps, humans still escalate edge cases. Internal calling creates a consistent escalation path AI can route into.
• Operational traceability: If your supply chain and procurement teams care about root-cause analysis, you need a record of what happened. Calls initiated from the workspace can be correlated with contact flows, events, and outcomes.

Snippet-worthy truth: AI can reduce handle time, but collaboration reduces “time-to-correct-decision.” In supply chain support, that’s often the metric that actually matters.

The architecture: a simple pattern that scales

The cleanest approach is to treat agent-to-agent calling as a lightweight app embedded in the workspace, backed by standard AWS building blocks. The RSS solution uses:

• Amazon Connect for contact flows and call handling
• Kinesis streaming for agent events and contact trace records (CTRs)
• DynamoDB to store agent presence/availability (or any “who’s online” index)
• AWS Lambda to read/write presence and to initiate outbound calls
• API Gateway to expose a secure endpoint the 3P app can call
• AWS AppSync (optional) to query presence via GraphQL and enable real-time updates
• React (or any web UI) as the embedded 3P widget

What makes this pattern useful (beyond the demo)

This design is more than a call button:

1. It’s modular. You can upgrade presence logic, auth, routing rules, or UI without redesigning Connect.
2. It’s automation-ready. The same API that starts an internal call can later be used by workflow automation (for example, an AI agent that triggers a supervisor call when risk is detected).
3. It’s governance-friendly. Calls route through Connect contact flows, which means controls, recording policies, and analytics can be applied consistently.

Build it: agent-to-agent calling as a 3P app in Agent Workspace

You’re implementing three capabilities: (1) track availability, (2) route internal calls, (3) let the workspace UI initiate those calls.

1) Presence management: DynamoDB as the “who’s available” source

Answer first: Store agent presence in DynamoDB and expose it to the UI.

A typical record can include a business unit grouping key, agent login, status, and timestamps. The RSS example uses a partition key like PK = <BUSINESS_UNIT> and sort key Login = <CONNECT_USER_ID>. That’s a good idea because it supports:

• Listing peers in the same team/queue/region
• Filtering by business unit (procurement vs logistics vs returns)
• Scaling reads without building a complex directory

Practical enhancement I recommend: add a TTL attribute (time-to-live). Presence data is perishable; TTL prevents stale “Available” status from living forever after a disconnect.

2) AppSync + Lambda resolver (optional) for a cleaner UI query layer

Answer first: If you want a responsive UI and room for growth, put AppSync in front of DynamoDB.

The RSS approach uses a Lambda resolver with two operations:

• getAgentStatus(PK, Login)
• updateAgentStatus(...)

That’s enough to ship. But it also creates a nice future path:

• Real-time subscriptions (presence updates without polling)
• Role-based field visibility (for example, supervisors see more)
• Adding search fields (skills, language, escalation type)

3) Internal call routing: keep it in Amazon Connect contact flows

Answer first: Use a dedicated contact flow for internal calls so you can govern, measure, and change routing without redeploying the app.

A basic internal flow does three jobs:

1. Collect the target (agent ID, phone number, or a lookup key)
2. Invoke a Lambda function to resolve the destination
3. Transfer to agent (or phone number) based on your design

For contact centers supporting supply chain and procurement, add one more best practice: tag the contact with an “escalation reason.” That single attribute makes analytics dramatically easier later (late shipment, damaged goods, supplier dispute, price mismatch, etc.).

4) Call initiation: a Lambda that starts an outbound voice contact

Answer first: Expose a controlled “start internal call” capability via Lambda + API Gateway.

The RSS example uses startOutboundVoiceContact with environment variables for instance ID, contact flow ID, and source number. That’s a solid foundation.

Two production-grade upgrades that reduce risk:

• Validate inputs (agent ID format, allowed business unit, allowed destination) before initiating any contact.
• Rate limit per agent and per tenant. Internal call APIs get abused accidentally (double-clicks) and intentionally (pranks) unless you add controls.

5) API Gateway: the boundary where security either happens or doesn’t

Answer first: Treat the API as a privileged operation and lock it down.

At minimum:

• Authenticate requests (SSO/JWT, IAM auth, or a private integration)
• Authorize by role (agent vs supervisor)
• Log request IDs and outcomes for audit

If you operate in regulated environments, decide early whether internal calls are recorded and how those recordings are retained. Keeping the call inside Connect makes that easier.

6) The 3P app: a small React widget that agents will actually use

Answer first: Keep the UI boring and fast: search, presence, click-to-call.

Agents don’t want a new “tool.” They want one fewer step.

A good v1 widget includes:

• Search by name, team, or escalation type
• Presence indicator (Available, Busy, Offline)
• One-click call
• A short “why I’m calling” dropdown (feeds the contact attribute)

A good v2 widget adds:

• Suggested experts (based on queue, historical resolution, or skills)
• “Warm handoff” notes (a structured summary that moves with the call)
• Callback scheduling (for SMEs who are busy)

Where AI fits next: make escalations smarter, not just faster

Once agent-to-agent calling is in place, AI can improve the quality of escalation, not just the speed.

AI upgrade #1: intent-based expert matching

Answer first: Route to the right internal person based on the problem, not the org chart.

In supply chain support, the “right person” often depends on context:

• Carrier issue vs warehouse issue vs supplier issue
• Domestic vs cross-border shipments
• Incoterms, payment terms, or compliance constraints

An AI classifier (even a simple one) can map the customer’s issue + order metadata to a recommended internal route.

AI upgrade #2: real-time summaries for warm transfers

Answer first: A 20-second AI summary can eliminate 2–4 minutes of re-explaining.

The most common escalation failure is repetition: the agent explains it, the SME asks again, the customer repeats details, and the clock runs.

A practical pattern:

• Generate a short call summary (what happened, order ID, promised date, what’s been tried)
• Attach it as call attributes or a companion note in the workspace
• Display it automatically to the receiving agent

AI upgrade #3: risk flags that trigger escalation automatically

Answer first: Use AI to detect high-risk interactions and nudge escalation early.

Examples that matter in procurement and logistics:

• Customer threatens chargeback or contract penalties
• A supplier dispute is likely to impact multiple POs
• Sentiment drops sharply after a delivery change

When flagged, the UI can prompt the agent to call a supervisor or a specialist—without waiting until the interaction is already lost.

Operational checklist: what teams forget (and pay for later)

Answer first: The tech is the easy part; adoption and governance are what make it stick.

Here’s a field-tested checklist to keep you out of trouble:

Metrics to track from week one

• Time-to-expert (seconds from escalation intent to expert connection)
• First contact resolution (FCR) for exception-heavy reasons (delivery issues, damaged items)
• Repeat contact rate within 7 days for escalated cases
• Internal call volume by reason (to identify process gaps)

Guardrails that prevent chaos

• Role-based access (who can call whom)
• Business unit boundaries (procurement agents shouldn’t spam tier-3 logistics)
• Quiet hours / on-call schedules for SMEs
• Rate limits and click protection

Change management that drives usage

• Put the widget where agents already look (not buried)
• Provide a short “when to call” rubric
• Train SMEs on how to receive escalations (what details to ask for, what to document)

People also ask: practical questions before you implement

Does agent-to-agent calling replace chat tools?

No. Chat is great for low-urgency questions. Internal calling is for time-sensitive escalation where a wrong decision creates downstream cost—refunds, reshipments, supplier penalties, and expedited freight.

Can this work across sites or BPO partners?

Yes, if your governance is solid. Use business unit partitioning, role-based authorization, and contact flows that enforce allowed destinations.

Is presence data mandatory?

Not mandatory, but it changes behavior. A presence indicator reduces “blind calling,” which reduces agent frustration and internal noise.

Next step: start small, then add intelligence

Agent-to-agent calling in Amazon Connect agent workspace is the kind of unglamorous capability that makes your AI roadmap real. It turns escalations into a controlled workflow instead of a scavenger hunt.

If you’re building AI-driven customer service for supply chain and procurement—demand volatility, late shipments, supplier risk, returns spikes—this is one of the best foundational upgrades because it improves the handoffs AI depends on.

If you want to pressure-test your design, start with one workflow: delivery exception escalations. Measure time-to-expert and repeat contacts for 30 days. Then decide where AI should step in next: expert matching, real-time summaries, or risk-triggered escalation.

What would happen to your backlog if every agent could reach the right internal expert in under 30 seconds—without leaving the workspace?