Enable agent to agent calling as a third-party (3P) application in Amazon Connect agent workspace

const AWS = require('aws-sdk'); 
const ddb = new AWS.DynamoDB.DocumentClient();</code><code class="lang-json"> </code><code class="lang-json"> const</code><code class="lang-json"> tableName = process.env.TABLE_NAME; 
exports.handler = async (event) =&gt; { 
 const { fieldName, arguments } = event; 
 if (fieldName === 'getAgentStatus') { 
  return await ddb.get({ TableName: tableName, Key: { PK: arguments.PK, Login: arguments.Login } }).promise(); }

 if (fieldName === 'updateAgentStatus') { 
  await ddb.put({ TableName: tableName, Item: arguments }).promise(); 
  return { success: true }; 
 } 
};

const AWS = require('aws-sdk'); 
const connect = new AWS.Connect();

exports.handler = async (event) => { 
  const params = { 
   InstanceId: process.env.INSTANCE_ID, 
   ContactFlowId: process.env.CONTACT_FLOW_ID, 
   SourcePhoneNumber: process.env.SOURCE_NUMBER, 
   DestinationPhoneNumber: event.targetAgentNumber 
 };

 await connect.startOutboundVoiceContact(params).promise(); 
 return { message: 'Call initiated successfully' }; 

};

• Under Configuration → Environment Variables, add:
  • INSTANCE_ID
  • CONTACT_FLOW_ID
  • SOURCE_NUMBER

Step 5: Expose API with API Gateway

• 1. Go to API Gateway → Create API → REST API → New API.
• 2. Name it AgentCallAPI.
• 3. Create a POST method under /initiateCall.
• 4. Integration type: Lambda Function, and select InitiateAgentCall.
• 5. Deploy the API to a new stage (e.g., prod).
• 6. Copy the Invoke URL to use in the React app.

Step 6: Build a 3P app for the agent workspace

• . Open your terminal and run:
  • npx create-react-app agent-caller-widget
  • cd agent-caller-widget
  • npm install axios
• Replace the contents of src/App.js with the following example:

import axios from 'axios';
function AgentList({ agents }) {
 const initiateCall = (agentId) => {
  axios.post('https://<api-id>.execute-api.us-east- 1.amazonaws.com/prod/initiateCall', { agentId }); 
 };
 return (
  <div>
   {agents.map(a => (
    <div key={a.Login}>
    {a.FirstName} {a.LastName}
    <button onClick={() => initiateCall(a.Login)}>Call</button>
   </div>
  ))}
  </div>
 );
 }
 export default AgentList;

Step 7: Embed the 3P app into the agent workspace

• Go to Amazon Connect → Agent applications → Third-party apps → Add new app.
• App name: Agent Caller.
• URL: Paste the hosted React app URL (from S3 or CloudFront).
• Add permissions for API access and DynamoDB read/write as needed.
• Save and verify that the app loads inside the Agent Workspace.

Cleaning up

Once you’ve tested and validated the Agent to Agent Calling integration, it’s important to clean up unused AWS resources to prevent ongoing charges. Below are the components you may want to delete:

• DynamoDB table
  • Navigate to the DynamoDB console
  • Locate the table created to store events
  • Select it and choose Delete table
• Agent Status Lambda function
  • Go to the Lambda console.
  • Find and delete the Lambda function.
• call initiation Lambda function
  • Locate and remove the Lambda function that served call initiation.
• API Gateway
  • In the API Gateway console, identify the API created to expose agent to agent calling.
  • Delete the API to prevent any further external calls and usage charges.
• Custom Amazon Connect contact flows
• React JS 3P widget in the agent workspace
  • Navigate to the Amazon Connect console.
  • Under Agent Application Settings, remove the 3P app (React widget) from the workspace configuration.
• IAM roles & permissions
  • Review any IAM roles created for the Lambda functions, API Gateway, or DynamoDB.
  • Detach unnecessary policies or delete unused roles to maintain a clean IAM setup.

Conclusion:

Agent-to-agent calling in Amazon Connect bridges communication gaps and enhances agent collaboration without needing external tools or additional infrastructure.

This version focuses on search and transfer capabilities, providing a simple and secure way for agents to connect internally. Using AWS-native services ensures flexibility, scalability, and a strong foundation for future enhancements such as presence awareness, internal call analytics, and real-time reporting.

---

About the authors