Microsoft Teams

Connect your agent to Microsoft Teams so it appears as its own named bot

Your agent can communicate with you and your team through Microsoft Teams, appearing as its own named bot. In channels, users @mention the bot to start a conversation; follow-up replies in the same thread keep flowing without needing to @mention again. In DMs and group chats every message reaches the bot directly. The agent can also send images and, in 1:1 chats, files it has created — see Working with files — and follow scheduled meetings it is added to, acting on the transcript when the meeting ends — see Meeting transcripts.

Example use cases

• “@Releaser time to cut a new release” — triggers your deployment agent directly in a channel
• “@Researcher summarise everything we know about Acme Corp” — kicks off a research agent from Teams
• “@Standup post a daily standup summary to the Engineering channel every morning”
• “After each sprint planning meeting, file the transcript in the project folder and post the action items with owners in the meeting chat” — an agent added to the meeting does this on its own when the meeting ends

Prerequisites

• Access to the Teams Developer Portal at dev.teams.microsoft.com
• Microsoft Entra admin center access (to copy the app registration’s IDs)
• Microsoft Teams Admin Center access (Teams administrator role)
• The Abundly agent you want to connect

Least-privilege by design. The agent’s access is granted through Resource-Specific Consent (RSC): it can only read the teams and chats where its app has been explicitly added, and that access is granted by the team owner or chat members at install time — and enforced by Microsoft. No tenant-wide Graph permissions are required. (A workspace can optionally grant broader tenant-wide permissions — see Optional: tenant-wide Graph permissions.)

An agent can do most of this for you. If your workspace has an admin-only agent with the Microsoft 365 Admin capability, ask it to mint the client secret, publish the app package to your org catalog and install it in a team. You approve each plan and sign in at Microsoft, and the agent never holds a credential. Creating the bot and pointing its messaging endpoint at Abundly still happens in the Teams Developer Portal.

How to connect

The setup takes about 15–20 minutes across the Teams Developer Portal, Microsoft Entra admin center, and Teams Admin Center.

1. Create the bot and a client secret

   1. Go to the Teams Developer Portal at dev.teams.microsoft.com and sign in with your work account
   2. In the top bar, go to Tools → Bots, click + New Bot, give it the same name as your agent (e.g. “Releaser”), and click Add — you’re taken straight to the bot’s Configure page
   3. Set the Endpoint address to the messaging endpoint URL shown in Abundly (format: https://your-domain/api/ms-teams/bot/YOUR-AGENT-ID) and click Save
   4. Go to Client secrets (in the bot’s left-hand menu), click Add a client secret for your bot, and confirm
   5. Copy the secret value immediately — it will not be shown again. You’ll paste this into Abundly’s Bot client secret field

   Creating the bot here automatically creates a matching app registration in Microsoft Entra; the client secret you just made is stored on that registration. You’ll pick up the Bot ID and Tenant ID from that same registration in the next step, with one-click copy buttons.

2. Grab IDs in Microsoft Entra

   1. Go to entra.microsoft.com and navigate to Entra ID → App registrations

   2. Find the app registration that was automatically created — it will have the same name as your bot — and click it to open the Overview page

   3. From the Overview page, copy:

      • Application (client) ID — this is your Bot ID (paste into Abundly’s Bot ID field)
      • Directory (tenant) ID — this is your Tenant ID (paste into Abundly’s Tenant ID field)

      Both fields have one-click copy buttons next to them — much easier than hunting these down elsewhere.

   No API permissions need to be granted here — the agent’s read access comes from the resource-specific consent permissions in the app manifest (next step), granted per team or chat at install time. Microsoft Entra ID is the new name for Azure Active Directory; if you prefer the Azure Portal, the same settings live under Microsoft Entra ID → App registrations at portal.azure.com.

3. Enter credentials in Abundly

   In your agent’s settings, open the Microsoft Teams integration panel and enter:

   Field	Where to find it
   Bot ID	Application (client) ID from step 2
   Bot client secret	Client secret from step 1
   Tenant ID	Directory (tenant) ID from step 2

   Click Save.

4. Create and publish the Teams app

   The quickest route is the app package Abundly builds for you. In the Microsoft Teams integration panel, click Download package under App package, then in the Teams Admin Center go to Teams apps → Manage apps → Upload new app and pick the file. The zip already holds the manifest and both icons (made from the agent’s picture, if it has one), and Abundly chose the app ID, so there is nothing to create in the Developer Portal and nothing to copy across. Skip to the next step once it’s uploaded.

   Download it again whenever you rename the agent or change its description or picture, and upload it the same way — the package keeps the same app ID, so Teams updates the existing app instead of adding a second one and existing installs keep working.

   Already created the app in the Developer Portal? Copy its app ID and paste it into Teams app ID under App package before you download. Teams identifies an app in your org catalog by that ID, so matching it means your upload updates the app you already have rather than publishing a second one next to it.

   To build the app by hand in the Developer Portal instead:

   1. Back in the Teams Developer Portal, go to Apps → New app and give it any name (the manifest you paste below will overwrite name, description, bot, and scopes anyway). You’ll land on the new app’s Basic information page; copy the App ID shown at the top — you’ll need it in step 3.
   2. Go to Branding and upload icons if desired (or skip — Teams shows a generic placeholder). Icons are binary uploads, not part of the JSON manifest, so this is the one thing the manifest paste can’t set for you.
   3. Go to App package editor and replace the manifest with one of:
      • The pre-filled manifest in Abundly’s Microsoft Teams integration panel (after credentials are saved, scroll to App manifest → Copy manifest) — this is already populated with your agent name, description, and Bot ID. Put the App ID you copied in step 1 into the Teams app ID field under App package first; the manifest then carries it and the paste works as-is. If that field is empty the manifest falls back to a REPLACE-WITH-TEAMS-APP-ID-FROM-DEV-PORTAL placeholder you must replace by hand. Teams locks the app id at creation, so the paste fails if the manifest’s id doesn’t match.
      • The reference template below, substituting the placeholder values yourself:

   Manifest template

   {
     "$schema": "https://developer.microsoft.com/en-us/json-schemas/teams/v1.29/MicrosoftTeams.schema.json",
     "version": "1.0.0",
     "manifestVersion": "1.29",
     "id": "YOUR-TEAMS-APP-GUID",
     "name": {
       "short": "YOUR-AGENT-NAME",
       "full": "YOUR-AGENT-NAME"
     },
     "developer": {
       "name": "YOUR-COMPANY-NAME",
       "websiteUrl": "https://your-company.com",
       "privacyUrl": "https://your-company.com/privacy",
       "termsOfUseUrl": "https://your-company.com/terms"
     },
     "description": {
       "short": "Abundly agent bot",
       "full": "Abundly agent bot for Microsoft Teams"
     },
     "icons": {
       "outline": "outline.png",
       "color": "color.png"
     },
     "accentColor": "#ffffff",
     "supportsChannelFeatures": "tier1",
     "bots": [
       {
         "botId": "YOUR-BOT-ID-GUID",
         "scopes": ["personal", "team", "groupChat"],
         "isNotificationOnly": false,
         "supportsFiles": true,
         "supportsTargetedMessages": true,
         "commandLists": [
           {
             "scopes": ["personal", "groupChat"],
             "triggers": ["slash", "mention"],
             "commands": [
               {
                 "title": "compact",
                 "description": "Start a new chat that begins with a summary of this one"
               }
             ]
           }
         ]
       }
     ],
     "webApplicationInfo": {
       "id": "YOUR-BOT-ID-GUID",
       "resource": "api://botid-YOUR-BOT-ID-GUID"
     },
     "authorization": {
       "permissions": {
         "resourceSpecific": [
           { "type": "Application", "name": "ChannelMessage.Read.Group" },
           { "type": "Application", "name": "ChatMessage.Read.Chat" },
           { "type": "Application", "name": "ChannelSettings.Read.Group" },
           { "type": "Application", "name": "ChannelMember.Read.Group" },
           { "type": "Application", "name": "OnlineMeeting.ReadBasic.Chat" },
           { "type": "Application", "name": "OnlineMeetingTranscript.Read.Chat" }
         ]
       }
     },
     "validDomains": []
   }
   

   Existing installs must bump manifestVersion to 1.29 and add supportsChannelFeatures, supportsTargetedMessages, "supportsFiles": true and the commandLists block by hand, then re-upload the manifest, to get /compact listed under View prompts in 1:1 chats and in the / menu in group chats, and to let the agent send files in 1:1 chats (see Working with files). Typing /compact works without that update. Teams caches app manifests, so if the entry does not show up after re-uploading, remove the app from the chat and add it again.

   The three GUIDs play two distinct roles:

   • id is the Teams app’s own identity in your org’s app catalog. It is auto-generated when you create the app shell (step 1) and locked thereafter — pasting a manifest with a different id triggers a “Property ‘id’ cannot be changed in the manifest” error. Use the App ID you copied in step 1.
   • bots[0].botId and webApplicationInfo.id must both equal your Application (client) ID from the Entra app registration overview (step 2). Teams ties RSC consent to webApplicationInfo.id, so it has to match the registration that owns the bot.

   What the RSC permissions do. These are Resource-Specific Consent (RSC) permissions, granted per team or chat when the app is installed there — this is the entirety of the agent’s read access, scoped to exactly the conversations where someone deliberately added it.

   • ChannelMessage.Read.Group — read channel messages in teams where the app is installed. Also unlocks webhook delivery of in-thread replies: without it, Teams only delivers @mentions, so follow-up replies in a thread would never reach the agent. Abundly only acts on @mentions or messages that continue a thread the user already opened with the bot.
   • ChatMessage.Read.Chat — read message history in group chats where the app is installed.
   • ChannelSettings.Read.Group — list a team’s channels (names and IDs) so the agent can find the right channel.
   • ChannelMember.Read.Group — read channel membership, needed for member listing and membership events in private and shared channels.
   • OnlineMeeting.ReadBasic.Chat — basic details of meetings the app is added to, and the notification that tells the agent a meeting has ended.
   • OnlineMeetingTranscript.Read.Chat — read the transcript of a meeting the app is added to. See Meeting transcripts.

   We currently recommend manifestVersion: "1.29" so the compose box can suggest /compact. From 1.25 upwards Teams requires the top-level supportsChannelFeatures property for apps with team scope; tier1 declares the app can be installed in shared and private channels without depending on channel membership for permissions. RSC requires 1.12 or higher.

   4. Click Save in the App package editor, then click Update app package when prompted (or via the banner that says “Your changes have been saved locally, but not yet updated in the app package.”). Without this step the app still uses the old manifest.
   5. Go to Publish → Publish to org and click Get Started (the publish action)

   The status should show Published to org or Submitted (awaiting admin approval).

   The Teams Developer Portal also offers Publish → App validation, but that’s a preflight aimed at apps being submitted to AppSource (the public Microsoft Teams Store). For internal org publishing it’s unnecessary — and it tends to surface scary “Failure” labels that are actually validator-side flake or store-only naming rules (“Short name should not contain ‘Microsoft’”, etc.). Skip it.

   Icon requirements are strict. Teams’ validator rejects anything that doesn’t match exactly:

   • Color icon: 192×192 PNG, full color
   • Outline icon: 32×32 PNG with only pure white (#FFFFFF) and fully transparent pixels — no anti-aliasing, no near-white. If you see “Outline icon is not transparent. It’s Alpha,R,G,B: …”, your export has soft edges; re-export with no smoothing.
5. Approve the app in Teams Admin Center

   1. Go to admin.teams.microsoft.com
   2. Navigate to Teams apps → Manage apps and search for your app name
   3. If the status shows Blocked (or pending approval), click on the app and click Publish to make it available org-wide

   Admin approval changes can take up to 30 minutes to propagate across the Microsoft Teams client.

6. Install the bot in a team

   1. In Microsoft Teams, click Apps in the left rail
   2. Look under Built for your org (or Added by your org) and find your bot
   3. Click the bot, choose Add to a team, pick the team and channel, and confirm
   4. The team owner must accept the requested RSC permissions when prompted — these are what let the bot read the team’s channels and see follow-up replies in a thread without re-mention

   Allow up to 30 minutes after publishing for the app to appear under Built for your org. Try a hard refresh (or sign out / sign in) if it’s slow to surface.

   Teams Admin Center’s Manage apps → Install action only manages org-level availability — it does not actually install the bot into a team. Use the in-client Apps → Built for your org flow above to install into a team.

   The bot is now live. Users can @mention it in a channel to start a conversation; subsequent replies in that thread continue without needing to @mention again.

How conversations work

Microsoft Teams is a full remote-chat surface — on par with Slack. Every Teams conversation maps to a persistent Abundly chat, giving the agent the same instructions, memory, and capabilities as it has in the portal.

• Channel @mentions start a new chat — the agent replies in the thread with full context.
• Follow-up replies in a thread the agent already joined continue the same chat without needing to @mention again.
• Group chats map to persistent chats — every message reaches the agent directly.
• 1:1 personal chats (DMs) also map to persistent chats — the agent replies naturally.
• In 1:1 chats, the agent’s reply streams in as it is written, with short status updates while it works.
• The agent reacts with 👀 to a message while it is working on it and removes the reaction when it has answered.
• Replies carry Teams’ “AI generated” label.
• In 1:1 and group chats, type /compact (or ask the agent to start fresh) to begin a new chat that starts with a summary of the current one. It takes a minute or two, and messages sent meanwhile are not answered. The previous chat stays readable in the portal. In a 1:1 chat the command is also listed under View prompts above the compose box; in group chats it appears in the / menu once you type /.
• You can tell an agent to leave a channel thread — say it’s no longer needed and it steps out, so it stops being woken by every following message. It says so in the thread before going quiet, and an @mention brings it straight back, caught up on what it missed. Agents are told not to leave on their own initiative: if one thinks it’s done, it asks or says so first. Group chats and personal chats can’t be left, so an agent is always reachable there.

These conversations appear in the sidebar alongside portal chats and can be filtered using the chat filter pill (e.g. Hide remote chats). Handoffs between Teams and the portal are seamless.

Working with files

The agent can send files it has created or fetched — agent documents, generated images, files from other capabilities — into Teams. What it can deliver depends on where the conversation is, because Microsoft only lets bots upload files to people’s OneDrive in 1:1 chats:

Conversation	Images	Other files (PowerPoint, Excel, PDF, …)
1:1 personal chat	Shown inline	The agent posts a file card with an Accept button. Once you accept, the file is uploaded to your OneDrive and appears as a file card in the chat.
Group chat	Shown inline	Not deliverable by the bot. With the SharePoint capability enabled, the agent uploads the file to SharePoint and shares the link instead; otherwise it tells you the file is saved in the chat’s documents in Abundly.
Channel thread	Shown inline in the thread	Same as group chats.

Sending files in 1:1 chats requires "supportsFiles": true in the app manifest (included in the manifest above). Apps installed with an older manifest need the manifest re-uploaded and published — see Updating an existing install. If the Allow button on a file card shows “This card action is not supported”, the Teams client is still running the old manifest: reload Teams (or sign out and in) after the updated version is published, then ask the agent to send the file again.

For a project agent that regularly produces documents for a group or channel, enable the SharePoint capability and point the agent at the project’s SharePoint site. It then drops the files there and links them in Teams, where everyone in the conversation can open them.

Meeting transcripts

An agent can read the transcript of a scheduled Teams meeting it was added to. When the meeting ends, the agent fetches the transcript and is triggered with it, the same way it is triggered by an incoming email: the run appears on the agent’s Activity page with the transcript attached as a document, and the agent follows its instructions — file the transcript, mail a recap, update a project log, or whatever you have told it to do. If the instructions say nothing about meetings, it posts a short summary with decisions and action items in the meeting chat. Anyone in the meeting chat can also ask the agent about the meeting afterwards.

What you need

1. Permissions in the app manifest — OnlineMeeting.ReadBasic.Chat and OnlineMeetingTranscript.Read.Chat, both included in the manifest above. Existing installs need the manifest re-uploaded and published, see Updating an existing install.
2. A Teams admin allows apps to read transcripts — in the Teams admin center go to Meetings → Meeting settings → Transcript API access, turn Microsoft Graph access on, and under Configure allow speaker attribution so the transcript keeps speaker names. Microsoft turned this off for every tenant in 2026; the change can take up to 30 minutes to apply.
3. The organizer adds the agent to the meeting — open the meeting chat, click the participants icon next to Join → Add agents, and pick the agent. Only the organizer or a presenter can grant the permissions this way. Do it before the meeting starts if you want the agent to act on its own when the meeting ends; adding it afterwards also works, but then someone has to ask it about the meeting in the chat.
4. Transcription is running during the meeting — start it under More → Record and transcribe, or set Record and transcribe automatically in the meeting options.

Tell the agent in its instructions what to do with transcripts: where to file them, what to summarise, whom to notify.

Only scheduled private meetings — calendar meetings, recurring ones included. Channel meetings and ad-hoc calls (Meet now) are not supported: Microsoft does not grant transcript access for them through resource-specific consent. If a meeting should reach the agent, schedule it as a regular calendar meeting with the participants and add the agent to it. To read a channel meeting’s transcript on request, an agent with Microsoft 365 Assistant can do so as an invited user.

The transcript usually appears a few minutes after the meeting ends. If none is published within about fifteen minutes — typically because transcription was never started — nothing happens and no Activity entry is created. If the tenant setting or the permissions are missing, the agent says so in the meeting chat.

Teams-originated chats are marked as “remote” and are read-only in the portal — reply from Teams to keep the thread in the agent’s working context. To continue the conversation in the app instead, use Duplicate chat from the chat menu; the copy is a regular portal chat with the same history and documents. Summarize for new chat in the chat menu now works on Teams direct and group chats and moves the Teams conversation to the new chat.

Private and shared channels

Private and shared channels are separate security boundaries in Microsoft: they have their own membership and their own message store, so the team-level install does not cover them. Installing the app in a team makes all its standard channels readable; a private or shared channel additionally requires the app to be added to that specific channel:

1. Make sure the app is installed in the channel’s host team (step 6 above).
2. Open the private or shared channel and add the app to it — a channel member does this from the channel’s app management (for example ⋯ → Manage channel → Apps, or by choosing the channel when adding the app).
3. The channel-level add grants the app’s RSC permissions for that channel only.

Once added, the channel works like any other: @mention the agent to start a thread, and the agent can read that channel’s messages on demand. Channels the agent cannot reach still show up in channel listings (names are team-level metadata), but reads return an instructive error instead of content.

For an incoming shared channel (shared into your team from another team), the app must be added from the channel’s host team — Teams does not allow adding apps from the receiving side.

Optional: tenant-wide Graph permissions

The standard setup above gives the agent read access only where its app is installed, enforced by Microsoft. Some capabilities require broader, tenant-wide Microsoft Graph application permissions instead. Granting them is a workspace decision — most workspaces should not:

Capability	Requires
Reading 1:1 chat history from before the agent was added (Microsoft does not support RSC message reads in personal chats — new messages always reach the agent)	Chat.Read.All
Reading messages in private and shared channels without adding the app to each channel (see Private and shared channels for the per-channel alternative)	ChannelMessage.Read.All
Listing all teams in the organization (instead of only teams where the app is installed)	Team.ReadBasic.All, Channel.ReadBasic.All
Looking up user profiles by Azure AD ID (get_ms_teams_user_info)	User.Read.All

To grant: in the bot’s app registration in entra.microsoft.com, go to API permissions → Add a permission → Microsoft Graph → Application permissions, add the permissions you need, and click Grant admin consent.

These are tenant-wide permissions: for example, Chat.Read.All allows the app registration to read every chat in the organization, not just conversations the agent participates in. Abundly agents only fetch conversations they are part of, but that restriction is not enforced by Microsoft the way RSC is. Prefer the RSC-only setup unless you specifically need one of the capabilities above.

Updating an existing install

Whenever you change the manifest (bumped version, added permissions, etc.), Teams will not automatically apply the change to teams that already have the bot installed — and the team owner is not re-prompted to consent to any new permissions. To apply the update:

1. Bump the manifest version in the Teams Developer Portal (e.g. 1.0.0 → 1.0.1) and re-publish the app to your org
2. In each team that has the bot installed: Manage team → Apps → trash icon next to the bot → Remove
3. Re-add the bot following step 6 above

Removing and re-adding (rather than the in-place “Update” option, which often does not re-trigger the consent dialog) is the most reliable way to ensure new permissions like ChannelMessage.Read.Group are actually granted.

To let an existing install send files in 1:1 chats, add "supportsFiles": true to the manifest as part of the same update, then reload Teams once the new version is published — see Working with files.

Things to know

One app per agent — each agent requires its own Microsoft Teams app and bot. There is no way to have multiple bot identities within a single Teams app.

Secret expiry — client secrets expire. Note the expiry date and rotate the secret in the Teams Developer Portal (Tools → Bots → your bot → Client secrets) or Microsoft Entra (your bot’s app registration → Certificates & secrets) and update it in Abundly before it expires. Once a secret has expired the integration panel shows a Bot authentication is failing banner — rotate the secret, update it in Abundly, then run Test connection to clear it.

Checking the connection

The Microsoft Teams integration panel has a Connection status section that answers the two questions setup leaves open:

• Test connection asks Microsoft to accept the Bot ID, client secret and Tenant ID. It is a live check, so it also catches a secret that has expired or been revoked since setup. It says nothing about whether the Teams app is published or installed.
• Installed in lists the teams, channels and chats where the agent’s Teams app is currently installed, as Teams reported them. An empty list after a successful test means the app was never added anywhere — or was removed. Allow up to 30 minutes after publishing for an install to show up.

Troubleshooting

Bot isn't responding to @mentions

Start with Connection status on the Microsoft Teams integration panel — it separates the two causes that look identical from Teams. If Test connection fails, the credentials are wrong or the secret has expired. If it succeeds but Installed in is empty, the app was never added to a team or chat.

• Add the bot to the channel — registering the bot in Entra is not enough; it must be installed into the Teams roster (step 6)
• Check the endpoint URL — verify the messaging endpoint in the Teams Developer Portal matches the URL shown in Abundly (https://your-domain/api/ms-teams/bot/YOUR-AGENT-ID)
• Verify credentials — confirm the Bot ID, Bot client secret, and Tenant ID are entered correctly in Abundly

Bot replies to the first @mention but ignores follow-up messages in the thread

This is the symptom of ChannelMessage.Read.Group not being granted in the team where the bot is installed. The Bot Framework webhook only fires for @mentions in channels by default — the RSC permission is what unlocks delivery for in-thread replies.

Verify and re-grant:

1. In the team: Manage team → Apps → click the bot row. Look for ChannelMessage.Read.Group (Application, Resource specific consent) under Permissions.
2. If it’s missing, the consent never took. The most reliable fix is to bump the manifest version, re-publish, then remove the bot from the team and re-add it (see Updating an existing install above). The in-place “Update” button often does not re-trigger the consent dialog.
3. In private and shared channels, the app must be added to the channel itself for messages to be delivered — see Private and shared channels.
4. The team must have owner consent — only team owners see the consent prompt during install, and only owners can grant RSC.
5. If everything looks granted but messages still don’t arrive, give it 10–30 minutes — Microsoft has documented occasional propagation delays for RSC delivery.

"BotNotInConversationRoster" error

The bot has not been installed into the team. Complete step 6 to add it to the roster.

Agent gets 403 Forbidden when reading a team, channel, or chat

The agent can only read conversations where its Teams app is installed (resource-specific consent). Either:

• Add the app to the team or group chat you want the agent to read — a team owner or chat member does this in the Teams client — or
• If the app was installed before the manifest’s RSC permissions were added, remove and re-add it so the new permissions are granted (see Updating an existing install), or
• For access beyond installed conversations, grant tenant-wide Graph permissions.

Private and shared channels are separate boundaries: the app must be added to the specific channel, not just the team — see Private and shared channels.

Can't find the bot under 'Built for your org'

• Wait — propagation from publish to visibility in the Teams client typically takes 5–30 minutes
• Confirm the app is approved in the Admin Center (step 5) and its status is Unblocked / Allowed, not Blocked
• Try a hard refresh in the Teams web client, or sign out/sign in on desktop
• Try the Teams web client at teams.microsoft.com — the desktop client caches aggressively

"Permissions needed" warning when adding the bot

Go to Microsoft Teams Admin Center → Teams apps → Permission policies → Global (Org-wide default) and ensure custom apps are set to Allow. If you’ve just made this change, try a hard refresh in your browser before retrying.

Manifest validation errors

• Ensure manifestVersion is "1.29" so /compact can appear in the compose box
• Ensure all fields in developer and description are filled in — empty {} objects will fail validation
• Ensure the id field is a plain GUID with no extra characters or braces
• Property 'id' cannot be changed in the manifest — Teams locks the Teams app id at app creation. The pasted manifest’s id must equal the App ID shown on your app’s Basic information page in the Teams Developer Portal. Copy that App ID into Teams app ID under App package in Abundly, then copy the manifest again — it carries whatever that field holds, and shows a REPLACE-WITH-TEAMS-APP-ID-FROM-DEV-PORTAL placeholder only while the field is empty.

/compact isn't listed when I type /

• In a 1:1 chat, agent commands never appear in the / menu — that menu is for group conversations. Use View prompts above the compose box instead, or just type /compact.
• In a group chat, make sure the manifest is on 1.29 with supportsTargetedMessages and the commandLists block (see the template above), then re-upload it.
• Teams caches app manifests. If the command still doesn’t show after re-uploading, remove the app from the chat and add it again.
• Typing /compact works in every case, with or without the menu entry.
• webApplicationInfo.appId required error: this means RSC permissions are declared but webApplicationInfo is missing or its id is empty. Set webApplicationInfo.id to your Bot ID (same GUID as bots[0].botId).

The agent does nothing after a transcribed meeting

• Was it a scheduled private meeting? Channel meetings and Meet now calls are not supported, see Meeting transcripts.
• Was the agent in the meeting chat before the meeting? The organizer adds it via the participants icon → Add agents. Check the chat for the “added the agent” system message.
• “Microsoft Graph access to meeting transcripts is turned off” posted by the agent: a Teams admin must turn on Transcript API access → Microsoft Graph access in the Teams admin center, then wait up to 30 minutes.
• “The agent’s Teams app is not allowed to read this meeting’s transcript”: the installed manifest predates the meeting permissions. Re-upload the manifest, publish, and add the agent to the meeting again.
• Transcript without speaker names: allow speaker attribution under Transcript API access → Configure.
• Nothing at all, no message: transcription was probably never started during the meeting. The agent only posts when a transcript exists.