← All Telegram MCP connectors

Goose · Block

Goose Telegram MCP — give Block’s agent your inbox

Add Entergram as an MCP extension in Goose, Block’s open-source AI agent, and let it work your real Telegram account — surface missed messages, chase leads that went cold, and act on chats autonomously.

MCP server URL https://mcp.entergram.com/mcp

Goose loads MCP servers as extensions. Register Entergram's as a Streamable HTTP extension and Block's open-source agent can autonomously work your real personal Telegram account — scoped by OAuth, with no bot account and no API keys.

Paste-ready configuration

~/.config/goose/config.yaml
extensions:
  entergram:
    type: streamable_http
    uri: https://mcp.entergram.com/mcp
    enabled: true

Ask Goose things you could never ask Telegram

With your personal account connected, Goose can act across every chat. Try prompts like:

  • “Sweep every unanswered client chat and draft a reply for each.”
  • “Create a priority column, then backfill it across all open chats.”
  • “Audit which of our partner groups share members with our customers.”
  • “Escalate any question asked more than twice into a ticket.”
  • “Consolidate the duplicate severity options into one clean set.”
  • “Distribute release notes to every channel that asked about this feature.”

Connect Goose in 3 steps

Works with the Goose desktop app and CLI.

  1. 01

    Copy your MCP URL in Entergram

    In Entergram, open Settings → Workspace → Connectors → MCP to find your endpoint. Goose prompts for this URL when you add Entergram as an extension.

  2. 02

    Add the extension in Goose

    In Goose, add a new extension of type Streamable HTTP pointing at the Entergram MCP URL: https://mcp.entergram.com/mcp.

  3. 03

    Authorize and run

    Launch a Goose session, complete the Entergram sign-in it triggers, and approve the scopes. The extension stays authorized across future sessions.

Three ways to run the Entergram extension

Goose Desktop

Open the extensions list, add a custom extension, pick the Streamable HTTP type and paste the URL. The desktop app handles the browser round-trip for you, so the consent screen appears once and every session after that starts already authorized.

Goose CLI

`goose configure` walks you through adding a remote extension without touching YAML — choose Add Extension, then the remote Streamable HTTP option. Editing ~/.config/goose/config.yaml by hand does exactly the same thing and is easier to keep in a dotfiles repo alongside the rest of your machine setup.

goose configure

Unattended runs

Once the extension is authorized, a headless invocation inherits it. This is how a Telegram sweep becomes something your machine does at 8am rather than something you remember to ask for — pair it with cron or launchd, because Entergram itself will not wake the agent.

goose run -t "List every Entergram chat that has been waiting on a reply for more than a day"

Long jobs, run to completion

Goose is built to hold a plan across many steps, and that changes what is worth asking for. These are jobs you would otherwise hand to a person for an afternoon. Each one is a single instruction; the tool sequence underneath is what Goose works out on its own, and every call lands in the session transcript so you can audit the path it took.

The task

«Go through every ticket open longer than three days, read the chat behind it, and draft a status update for each customer. Show me the drafts before anything goes out.»

Tools called

entergram_list_ticketsentergram_get_ticketentergram_list_messagesentergram_send_message

Goose returns

One instruction, four tool types, and a loop that runs as long as the queue is long. Goose filters by age, opens each ticket to find the conversation it came from, reads enough history to know what the customer is actually waiting on, and writes a per-ticket draft. It holds at the approval step — the send calls only fire for the drafts you keep.

The task

«Create a Deal stage column with the options Discovery, Trial, Negotiation and Closed, then classify every chat we spoke to last quarter into one of them.»

Tools called

entergram_create_custom_columnentergram_create_custom_column_optionentergram_list_workspace_chatsentergram_patch_chat_custom_fields

Goose returns

Schema and backfill in the same run, which is where an agent earns its keep: the column has to exist before a single value can be written, and the option values have to be read back so the classifier writes real option ids rather than free text. Expect it to run for a while and to hand back a per-chat list at the end. Workspace connector only.

The task

«Audit our three partner groups — who is in each, and which of our contacts show up in more than one?»

Tools called

entergram_list_groupsentergram_list_group_membersentergram_list_contact_shared_groups

Goose returns

A join that has no interface anywhere. Goose enumerates the groups, walks each membership list, then asks per contact which communities you and they both sit in, and folds the answers into an overlap table. What comes out is the list of people worth one message instead of three, plus the quiet discovery that two partners already know each other.

The task

«Find anyone who asked the same question twice and never got an answer, open a ticket for each, and paste both of their messages into the ticket as a comment.»

Tools called

entergram_list_messagesentergram_create_ticketentergram_create_ticket_comment

Goose returns

The detection step is the hard part and it is pure reasoning — two inbound messages with the same intent and no outbound turn between them. Everything after it is mechanical. The comment matters more than the ticket: whoever picks up the queue sees the exact wording that got ignored, quoted, without having to reconstruct the thread.

The task

«Our ticket severity column has drifted and three options now mean the same thing. Consolidate them down to one canonical set.»

Tools called

entergram_list_ticket_custom_columnsentergram_list_ticket_custom_column_optionsentergram_update_ticket_custom_column_optionentergram_update_ticket

Goose returns

Housekeeping nobody ever schedules. Goose reads the ticket schema, groups the near-duplicate options, renames the survivors, and moves the tickets still sitting on retired values across before anything is dropped. Watch the transcript the first time you run it — this is a plan whose first three decisions tell you whether the rest will be right.

The task

«Send the new release notes to every group where we have posted release notes before.»

Tools called

entergram_list_groupsentergram_list_messagesentergram_list_accountsentergram_send_media_message

Goose returns

Goose derives the target list from evidence rather than from a list somebody maintains: it scans past history for the groups that have received this kind of post, confirms the pattern holds, resolves which connected account owns each of them, then attaches the file and sends. The full group list is reported before the first send, so a bad inference costs you a no rather than an apology.

What Goose can do with your Telegram

  • Execute long multi-step jobs without supervision
  • Create a CRM column and backfill it in one run
  • Audit overlap between your groups and partner communities
  • Escalate repeated questions into tickets automatically
  • Consolidate messy option values into a clean set
  • Runs headless, so it fits a scheduled job

The extension’s full tool surface

Enabling the extension registers 70 tools across 9 groups into the session. Goose decides which to chain and in what order, so the grouping below is less a menu than a map of how they relate. Note where the destructive edges are — group administration, schema deletion, outbound sends — because those are precisely the ones a personal agent cannot reach at all.

Accounts & workspace

5 tools

Identity and scope discovery. Every message call needs an account_id from list_accounts first — an AI client that skips this step will address the wrong Telegram account.

  • entergram_get_me
  • entergram_list_accounts
  • entergram_get_workspace
  • entergram_get_member
  • entergram_list_members

Chats & discovery

8 tools

Finding conversations. The workspace views carry CRM state (tickets, comments, custom fields); the live views carry current Telegram transport state and unread counts.

  • entergram_list_chats
  • entergram_get_chat
  • entergram_list_live_chats
  • entergram_get_live_chat
  • entergram_list_workspace_chats
  • entergram_get_workspace_chat
  • entergram_update_workspace_chat
  • entergram_get_chat_management

Messages

9 tools

Reading and writing message history, including edits, forwards and reactions. Sending is scoped per account, so nothing is global across your connected accounts.

  • entergram_list_messages
  • entergram_get_message
  • entergram_send_message
  • entergram_send_media_message
  • entergram_edit_message
  • entergram_delete_message
  • entergram_forward_messages
  • entergram_get_message_reactions
  • entergram_set_message_reactions

Contacts

3 tools

Who you are talking to, and where else you overlap with them. Shared-groups lookup is what makes questions like “which of my leads are in the same community?” answerable.

  • entergram_list_contacts
  • entergram_get_contact
  • entergram_list_contact_shared_groups

Tickets

10 tools

Full support-desk control: open, assign, prioritise, comment and close. Tickets link back to the chat they came from, so an AI client can move from conversation to queue in one step.

  • entergram_list_tickets
  • entergram_get_ticket
  • entergram_create_ticket
  • entergram_update_ticket
  • entergram_delete_ticket
  • entergram_list_chat_tickets
  • entergram_list_ticket_comments
  • entergram_create_ticket_comment
  • entergram_update_ticket_comment
  • entergram_delete_ticket_comment

CRM custom fields

11 tools

Your pipeline schema. Read the columns before writing values — checkboxes take booleans, multiselects take arrays of option values, dates take ISO 8601 strings.

  • entergram_list_custom_columns
  • entergram_get_custom_column
  • entergram_create_custom_column
  • entergram_update_custom_column
  • entergram_delete_custom_column
  • entergram_list_custom_column_options
  • entergram_create_custom_column_option
  • entergram_update_custom_column_option
  • entergram_delete_custom_column_option
  • entergram_get_chat_custom_fields
  • entergram_patch_chat_custom_fields

Ticket custom fields

9 tools

The same schema control for the ticket side — categories, severities, SLA tiers and anything else your desk tracks beyond status and priority.

  • entergram_list_ticket_custom_columns
  • entergram_get_ticket_custom_column
  • entergram_create_ticket_custom_column
  • entergram_update_ticket_custom_column
  • entergram_delete_ticket_custom_column
  • entergram_list_ticket_custom_column_options
  • entergram_create_ticket_custom_column_option
  • entergram_update_ticket_custom_column_option
  • entergram_delete_ticket_custom_column_option

Internal notes

4 tools

Comments on a chat that your customer never sees. Useful for letting an AI client leave its reasoning behind for a human teammate to pick up.

  • entergram_list_chat_comments
  • entergram_create_chat_comment
  • entergram_update_chat_comment
  • entergram_delete_chat_comment

Groups & channels

11 tools

Creating and administering Telegram groups and channels — membership, permissions, privacy and info — plus a raw command escape hatch for the rest.

  • entergram_list_groups
  • entergram_get_group
  • entergram_list_group_members
  • entergram_create_group_chat
  • entergram_create_channel
  • entergram_invite_chat_members
  • entergram_remove_chat_member
  • entergram_update_chat_info
  • entergram_update_chat_permissions
  • entergram_update_chat_privacy
  • entergram_run_chat_command

Scopes, and why an autonomous agent wants fewer of them

Authorization is an ordinary OAuth login in your browser: Goose opens Entergram’s consent screen, you approve, and the resulting token sits in your local Goose configuration rather than on anyone’s server. The Telegram session itself stays behind Entergram: the number you signed up with and the login it is tied to are never handed to Block’s agent, and never to whichever model provider you have Goose pointed at either. Because an agent acts while you are looking somewhere else, the access level you choose here is the real safety control, not the prompt.

Personal agent
Open to any workspace member. It can read the workspace and its members, the connected accounts, your contacts, chat list, message history and ticket queue; the only thing it writes is custom fields on chats belonging to accounts you connected yourself. An agent holding this token can research and report all day and still cannot say a word to a customer, which is usually the correct trade for a run you are not watching.
Workspace connector
Restricted to owners and admins, and it carries the whole scope set — outbound messages, custom-field writes on any chat, ticket and schema changes, group administration. Hand this to a Goose instance only when the plan genuinely has to act on the workspace’s behalf, and keep it off machines other people can sit down at.
Killing access mid-run
Two switches, and they work at different levels. Disabling the extension in Goose stops the current agent reaching Entergram at all. Revoking the token under Settings → Workspace → Connectors → MCP invalidates it everywhere at once, including a run already in progress on another machine.

Where an autonomous run hits a wall

Constraints worth knowing before you hand Goose a plan and walk away from the screen.

  • Tool calls need a Pro workspace. MCP is a Pro-plan feature in Entergram, so the OAuth handshake completes on any tier and then the first tool call in your plan fails — an unpleasant thing to discover forty minutes into a run.
  • A personal agent cannot finish a plan that ends in a send. If the final step is outbound, the run needs a workspace connector, and only an owner or admin can create one.
  • Nothing schedules Goose except you. Entergram exposes no trigger that wakes an agent, so recurring work means cron, launchd, or whatever runner you already use invoking Goose on the interval you want.
  • There is no broadcast primitive. Every message tool resolves one account_id and one chat, so an agent that decides to contact forty people makes forty separate calls — each visible in the transcript, and stoppable partway through.
  • History is not bottomless. Deep reads across a busy group are bounded by Telegram’s own retention and paging behaviour rather than by Entergram, so a plan that assumes it can walk a full year of a large group will come back short without saying so loudly.
  • Long reads cost model tokens. Goose runs on whichever provider you configured it with, and a plan that pulls thousands of messages into context is billed there — narrow by chat, date range or ticket queue before letting it loose.

When a Goose run goes sideways

The extension is listed but no tools appear
Goose reads its extension list when a session starts, not while one is open. Confirm the entry carries `enabled: true`, then start a fresh session — a resumed session keeps whatever tool list it was created with.
The CLI hangs at the authorization step
The consent screen needs a browser, and an SSH session or container has nothing to open one with. Authorize once from a desktop session; headless invocations afterwards reuse the stored token.
Goose tries to launch a binary and fails
The wrong extension type got picked. Entergram is a hosted server reached over Streamable HTTP, not a command-line extension — a command-type entry sends Goose looking for an executable that was never on your machine.
The run stops halfway with a permissions error
The plan crossed from reading into writing. A personal agent cannot send messages, edit other people’s chat fields or administer groups, so either ask an owner or admin for a workspace connector, or rewrite the plan to stop at a draft.
It acted on the wrong Telegram account
With several accounts connected, an unqualified instruction leaves the choice to the model. Name the account in the prompt and require an entergram_list_accounts call up front so the account_id gets resolved from data rather than guessed.
Edits to config.yaml seem to be ignored
YAML is indentation-sensitive and a mis-nested extensions block parses into nothing at all, silently. Run `goose configure` and add the remote extension through the menu instead — it writes the same file correctly and you can diff it afterwards.

Goose + Telegram FAQ

How does Goose connect to MCP servers?
Goose connects to MCP servers as extensions. Add Entergram as a Streamable HTTP extension with the MCP URL and authorize via OAuth.
Is this a Telegram bot?
No. Bots run on the Bot API and only see what is addressed to them. Goose reaches your own account through a hosted MCP server, so an autonomous run has the same view you do.
Is it secure?
Yes. OAuth 2.0 with scoped permissions; you decide what Goose can access and can revoke it at any time.
Can Goose run multi-step Telegram actions?
Yes. As an autonomous agent, Goose can chain steps in one run — read unanswered chats, draft replies and open tickets — pausing for your approval before anything is sent.

Goose Telegram MCP — give Block’s agent your inbox