How to connect AI agent to Microsoft Teams

Key takeaways

• Teams should be the decision surface, not a log file for every agent event.
• The safest pattern is agent runtime -> Contro1 approval layer -> Microsoft Teams -> signed callback -> agent resumes.
• Start with one risky action, one owner, one SLA, and one audit trail before expanding the workflow.
• Contro1 lets teams start free with up to 1,000 approval actions per month and unlimited audit log viewing for the last month.

Connect your agent to Teams in a few minutes

If your agent already runs in OpenAI Agents SDK, LangGraph, Claude, Microsoft Agent Framework, n8n, a custom backend, or any other runtime, you do not need to rebuild it as a Teams bot just to ask for human approval.

The practical pattern is simple: your agent pauses before a risky tool call, sends an approval request to Contro1, the right person answers in Microsoft Teams, and Contro1 sends a signed callback back to your agent so the workflow can continue.

Create free account

The recommended architecture

Think of Microsoft Teams as the human decision surface and Contro1 as the runtime control layer. Teams is excellent for reaching the person who owns the decision. Contro1 handles routing, escalation, callback integrity, and the audit trail across agent frameworks.

1. Create your free Contro1 account

Create a free Contro1 account and use it as the shared approval path for your first agent. You can start alone, connect one Teams workspace, and send real approval requests without paying upfront.

For a clean first test, pick one agent and one action that should never run silently: sending a customer message, changing a record, spending budget, deleting data, or publishing content.

• Use one owner for the first approval rule.
• Use one Teams destination for the first test.
• Use one callback URL so the agent can receive the final decision.
• Keep the first payload small, then add richer business context after the loop works.

Open free signup

2. Create an API key and webhook

In Contro1, create an API key for the agent and add the webhook URL where Contro1 should send the final decision. This is the endpoint your agent runtime uses to resume after a human approves or rejects the action.

The webhook should treat the Contro1 response as an execution decision, not as a chat message. Approve means the agent may continue with the specific proposed action. Reject means it must stop, explain, or follow your fallback path.

3. Connect Microsoft Teams

Connect Microsoft Teams from Contro1 Settings, then choose where approval requests should appear. The goal is not to mirror every agent event into Teams. The goal is to send only the decisions that need a human owner.

When the integration is connected, send one test request from the agent. The reviewer should see the proposed action, the business object, the reason approval is required, and the deadline for response.

• Use Teams for approvals and short comments, not raw telemetry.
• Route requests to a role or owner, not only to a generic channel.
• Add an SLA so unanswered requests escalate instead of hanging.
• Include enough context so the approver can decide without opening five other systems.

4. Send a Teams approval test in Contro1

Start with a tiny approval request before wiring every tool call. A good first request asks the reviewer to approve or reject one concrete action, then returns the decision to your webhook.

Once that loop works, expand the policy to other sensitive actions. Low-risk reads, summaries, drafts, or status checks can stay autonomous or audit-only. Actions that change systems, customers, money, access, or public content should pause for approval.

{
  "source": "sales-agent",
  "type": "approval",
  "title": "Approve customer-visible email?",
  "context": {
    "proposed_action": "Send follow-up email",
    "business_object": "Opportunity ACME-1042",
    "policy_trigger": "Customer-visible message",
    "deadline_minutes": 15
  },
  "callback_url": "https://your-agent.example.com/contro1/callback"
}

5. Resume the agent with a signed callback

After the reviewer answers in Teams, Contro1 sends the decision back to your callback URL. Your agent should verify the callback, match it to the pending action, and continue only if the decision is approved.

Do not treat a free-text Teams reply as permission to execute. The callback should carry a structured decision, reviewer identity, timestamp, request id, and the exact action that was approved or rejected.

• Approve: resume the pending tool call with the approved parameters.
• Reject: stop the action and return a clear explanation to the user or workflow.
• Timeout: escalate or run the safe fallback path.
• Comment: attach reviewer feedback to the workflow state before continuing.

Teams SDK, Copilot Studio, and Contro1

Microsoft gives you several valid ways to bring agents into Teams. Those tools solve the Teams connection. Contro1 solves the control layer: who is allowed to approve, how the request follows the organizational hierarchy, when it escalates, what the agent may do next, and where the audit trail lives.

In practice, Contro1 should sit beside any Teams integration path. It gives the organization one place to govern current and future agents, even when different teams use Copilot Studio, Teams SDK, Graph, OpenAI, LangGraph, Claude, n8n, MCP tools, or custom runtimes.

What to include in every Teams approval

Weak approval prompts create approval theater. A good Teams approval gives the reviewer enough context to make a real decision and gives the system enough structure to resume safely.

• Proposed action: the exact tool call or business action the agent wants to run.
• Business object: customer, ticket, invoice, repository, campaign, document, or record id.
• Risk trigger: why this action requires human review.
• Approver context: the role or owner responsible for the decision.
• SLA and escalation: when the request times out and who receives it next.
• Callback destination: where the signed decision returns.
• Audit evidence: request id, reviewer, timestamp, decision, comment, and final outcome.

Common mistakes to avoid

Most Teams integrations fail because they send too much, ask the wrong person, or cannot prove what happened after approval. Keep the first production flow narrow and auditable.

Start free, then expand the control layer

The fastest path is not a big migration. Connect Teams, send one approval request, verify the callback, and review the audit record. After that, add more rules, owners, SLAs, and frameworks.

Contro1 is free for up to 1,000 approval actions per month, with unlimited audit log viewing for the last month, so a team can validate the Teams approval loop before committing to a larger rollout.

Create free account · Read the Requests API docs · How to connect AI agent to Slack

Frequently asked questions

How do I connect an AI agent to Microsoft Teams?

Create a Contro1 account, create an API key and callback webhook, connect Microsoft Teams in Contro1 Settings, then have your agent send approval requests before risky actions. Reviewers answer in Teams and Contro1 sends a signed callback back to the agent.

Can I connect an existing OpenAI or LangGraph agent to Teams?

Yes. Keep the agent in its current runtime and use Contro1 as the approval layer. The agent calls Contro1 when a risky tool action needs review, and the human decision is delivered through Teams.

Is Contro1 free for Microsoft Teams approvals?

You can start free with up to 1,000 approval actions per month and unlimited audit log viewing for the last month. That is enough to connect Teams, test the full approval and callback loop, review evidence, and validate a first workflow.

Should Teams be used for every agent event?

No. Teams should be used for human decisions and short operational updates. Logs, traces, and telemetry belong in observability systems or audit records.

What is the difference between Teams approvals and Contro1 approvals?

Teams is the user-facing place where the human answers. Contro1 is the control layer that routes the request, applies escalation, returns a signed callback, and keeps a unified audit trail across agent frameworks.