Use casesWorkflow

AI Event Coordination Agent

Keep speaker applications, sponsorship enquiries, and attendee questions moving. Your agent sends requested updates and handles replies from a real mailbox on your event domain.

Create a mailbox Explore the product

The problem

Every event creates conversations that need an answer. A speaker applicant asks about the programme. A sponsor requests package details. A registered attendee needs help with their ticket. Each reply depends on the person's application, request, or registration.

Organizers often track those conversations across spreadsheets and individual inboxes. Venue questions, agenda changes, and missing speaker details arrive at the same time. Important replies get buried while the team switches between threads.

A useful event workflow connects each update to its reply. When a speaker changes their availability or an attendee asks a follow-up question, the agent needs the full conversation and the event details your team has approved.

How an AI agent solves this

An AI event coordinator operates a real mailbox like events@devcon2026.io — responding to applications and enquiries, answering questions, and sending agreed event updates. Your registration and application forms record permission for those communications; the agent stays within that scope.

  • Responds to speaker applications with decisions, session details, and scheduling questions
  • Handles replies instantly — answers logistic questions, sends venue details, shares agenda drafts
  • Sends requested sponsorship information and routes negotiations to your team
  • Tracks response status and stops follow-ups when someone declines or opts out
  • Sends logistics and other event updates that registered attendees agreed to receive
  • Checks recipient permission and suppressions before every send

How it works with Robotomail

Robotomail provides your agent with a real email identity on your event domain. Full send and receive — no SMTP setup, no mail server ops. Your agent sends from a professional address, receives replies, and maintains threaded conversations automatically.

1. Provision an event mailbox

Create mailbox
curl -X POST https://api.robotomail.com/v1/mailboxes \
  -H "Authorization: Bearer rm_live_key" \
  -H "Content-Type: application/json" \
  --data-binary @- <<'JSON'
{
  "address": "events",
  "domainId": "dom_devcon2026",
  "displayName": "DevCon 2026 Team"
}
JSON

2. Respond to a speaker application

Start with a submitted application and the speaker's permission to receive application updates. After your team approves the decision, the agent sends the next steps through the Robotomail API. Public talks, papers, or contact details alone do not authorize an invitation; see the Acceptable Use Policy.

Send application update
# Verify the speaker application, email permission, and suppressions before sending.
curl -X POST https://api.robotomail.com/v1/mailboxes/{mailbox_id}/messages \
  -H "Authorization: Bearer rm_live_key" \
  -H "Content-Type: application/json" \
  --data-binary @- <<'JSON'
{
  "to": [
    "speaker@example.com"
  ],
  "subject": "Your DevCon 2026 speaker application",
  "bodyText": "Hi Dr. Chen,\n\nThank you for applying to speak at DevCon 2026 and asking for application updates by email. Your proposed session on distributed agent architectures has been accepted for the AI Infrastructure track.\n\nThe event runs October 15-17 in San Francisco. Could you confirm your availability for a 30-minute session? Reply with any questions about the programme or travel arrangements.\n\nIf you withdraw your application or no longer want these updates, let us know here.\n\nBest,\nDevCon 2026 Team"
}
JSON

3. Register a webhook for replies

Register webhook
curl -X POST https://api.robotomail.com/v1/webhooks \
  -H "Authorization: Bearer rm_live_key" \
  -H "Content-Type: application/json" \
  --data-binary @- <<'JSON'
{
  "url": "https://your-app.com/api/event-inbox",
  "events": [
    "message.received"
  ],
  "mailboxId": "mbx_events_01"
}
JSON

4. Process replies and follow up

When a speaker or sponsor replies, your webhook receives the full message with thread context.

Webhook payload
{
  "event": "message.received",
  "timestamp": "2026-03-22T09:15:00Z",
  "data": {
    "message_id": "11111111-1111-4111-8111-111111111111",
    "mailbox_id": "22222222-2222-4222-8222-222222222222",
    "mailbox_address": "events@devcon2026.io",
    "from": "speaker@example.com",
    "to": [
      "events@devcon2026.io"
    ],
    "cc": [],
    "subject": "Re: Your DevCon 2026 speaker application",
    "body_text": "Thank you for accepting my session. Could you send the agenda and travel details so I can confirm the dates?",
    "thread_id": "33333333-3333-4333-8333-333333333333",
    "received_at": "2026-03-22T09:15:00Z",
    "attachments": []
  }
}

5. Agent handles the conversation

Your application stores event-specific email permission and cancels scheduled follow-ups when it is withdrawn. The CRM, classification, and scheduling functions below are examples of your application logic; Robotomail supplies the email transport.

Agent logic
async function getReplyMessageId(mailboxId, messageId) {
  const response = await fetch(
    `https://api.robotomail.com/v1/mailboxes/${encodeURIComponent(mailboxId)}/messages/${encodeURIComponent(messageId)}`,
    { headers: { Authorization: `Bearer ${process.env.ROBOTOMAIL_API_KEY}` } },
  );
  if (!response.ok) throw new Error(`Fetch message failed: ${response.status}`);
  const { message } = await response.json();
  if (!message?.messageId) throw new Error("Original email has no Message-ID");
  return message.messageId;
}

async function handleEventReply(payload) {
  const { from, subject, body_text: text, thread_id: threadId, mailbox_id: mailboxId, message_id: messageId } = payload.data;

  // Identify the contact in your event CRM
  const contact = await db.contacts.findByEmail(from);
  if (!contact) return;

  // Classify the reply intent
  const intent = await classifyReply(text);
  // => { sentiment: "interested", action: "needs_info", topics: ["travel", "agenda"] }

  // Handle withdrawals before generating a reply or scheduling another send.
  if (intent.action === "unsubscribe" || intent.sentiment === "declined") {
    await db.contacts.update(contact.id, { eventEmailConsent: false, status: "declined" });
    await db.followUps.cancelForContact(contact.id);
    return;
  }
  // Recorded permission belongs to this event and communication scope.
  if (contact.eventEmailConsent !== true) return;

  // Update contact status
  await db.contacts.update(contact.id, {
    status: intent.sentiment === "interested" ? "confirmed_interest" : "needs_review",
    lastRepliedAt: new Date(),
  });

  if (intent.action === "needs_info") {
    // Generate a personalized follow-up with requested details
    const followUp = await generateFollowUp({
      contactName: contact.name,
      requestedTopics: intent.topics,
      eventDetails: await db.events.getDetails("devcon-2026"),
    });

    await fetch(`https://api.robotomail.com/v1/mailboxes/${mailboxId}/messages`, {
      method: "POST",
      headers: {
        "Authorization": "Bearer rm_live_key",
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        to: [from],
        subject: `Re: ${subject}`,
        bodyText: followUp,
        inReplyTo: await getReplyMessageId(mailboxId, messageId),
      }),
    });
  }
}

Key benefits

  • Relevant answers.Use the speaker's application, the sponsor's enquiry, or the attendee's registration to answer the question they actually asked.
  • Two-way conversations. Unlike blast email tools, your agent receives and processes replies. Speakers can ask questions and get immediate, contextual answers.
  • Professional identity. Emails arrive from your event domain with proper SPF, DKIM, and DMARC — not a random SaaS subdomain. Deliverability stays high.
  • Organized event inboxes. Coordinate speakers, sponsors, and attendees from different mailboxes, all managed through a single API account.
  • Response tracking. Every reply is classified and logged. Know exactly who accepted, who declined, who needs follow-up — without manual spreadsheet updates.

Read the documentation to get started, or learn more about the platform in our launch post. Ready to build? Get started — paid plans come with a 30-day money-back guarantee.

Connect the workflow to a real reply

The webhook's data.message_id is a database ID used to retrieve or deduplicate a message. Fetch it with the GET message endpoint, then use the response's message.messageId (the RFC Message-ID) as inReplyTo. Keep data.thread_id for your application's conversation state. Do not use a database ID or thread ID as a reply header. Stop and investigate if the fetched message has no Message-ID.

Examples use illustrative IDs. Replace them with IDs from your account; never construct an email Message-ID from a database ID. Exchange mail only between your agent and your verified email address. Upgrade to email anyone. See plans for higher limits.

Verify the webhook signature over the raw body, persist the event and deduplicate on the database message ID before acknowledging it. Run your application logic from a durable queue. The database, calendar, CRM and model functions shown above belong to your application.

This shell example fetches an incoming email and builds all required send fields. Set ROBOTOMAIL_API_KEY, ROBOTOMAIL_MAILBOX_ID and ROBOTOMAIL_MESSAGE_ID in your environment. Apply your recipient and approval rules before sending.

# Requires jq. Use mailbox_id and message_id from the verified webhook.
original=$(curl --fail --silent --show-error \
  "https://api.robotomail.com/v1/mailboxes/$ROBOTOMAIL_MAILBOX_ID/messages/$ROBOTOMAIL_MESSAGE_ID" \
  -H "Authorization: Bearer $ROBOTOMAIL_API_KEY") || exit 1

payload=$(printf '%s' "$original" | jq -e --arg body "Thanks, I received your message." '
  .message | if (.messageId | type == "string" and length > 0) then
    {to: [.fromAddress], subject: ("Re: " + .subject), bodyText: $body, inReplyTo: .messageId}
  else error("Original email has no Message-ID") end
') || exit 1

curl --fail --silent --show-error \
  "https://api.robotomail.com/v1/mailboxes/$ROBOTOMAIL_MAILBOX_ID/messages" \
  -H "Authorization: Bearer $ROBOTOMAIL_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary "$payload"

Read receive and reply and webhook verification for the full setup.

Ready to build this?

Create a mailbox

Create a mailbox and connect one useful workflow. Your application controls the agent and its actions.