Slack Daily Standup Summary Agent With Jira, Linear, and Calendar
Learn how a slack daily standup summary agent collects async updates, checks Jira & Linear, and posts team summaries with blockers flagged.

A slack daily standup summary agent collects each team member’s async standup replies, checks progress in Jira or Linear, and posts a concise summary to the Slack channel, highlighting blockers. This guide covers how to build such an agent, connect the necessary tools, and ensure accurate reporting for distributed teams.
This guide covers one Slack process end to end. For the Slack API guide, connection setup and the full list of Slack use cases, see More Slack use cases.
Why This Process Breaks Today
Daily standups are a critical routine for engineering and product teams, but the async standup in Slack comes with some challenges:
- Team members post replies at different times, across time zones
- Slack threads scatter, making it hard to find or summarize updates
- Manual follow-up is required to verify claims against project trackers like Jira or Linear
- Blockers get lost or only surface the next day
- No standardized summary for leads or stakeholders
What should be a quick, informative touchpoint turns into scrolling through threads and cross-checking tickets.
The Systems and Data Involved
Slack Objects and Endpoints
- Channel ID where the standup thread lives
- Message Thread: the parent standup message, daily
- Replies (accessible via
conversations.replies) - User Info (via
users.info) - Posting Summary (using
chat.postMessage) - Reactions or Mentions: which can flag blockers or mention specific teammates
Linear and Jira
- Issue Change Events: status, assignee, comments (from Linear webhooks or Jira webhook events such as
jira:issue_updated) - API Search: mapping Slack usernames to Linear or Jira user IDs
- Project or Board Information: for determining backlog context
Google Calendar
- Attendee Lists: Confirming if members are out-of-office
- Event Summaries: Context for why standups may be missed
Code, Agent Judgment, and Human Approval
Divide the logic across software and Agent responsibilities:
What Code Can Do
- Schedule polling for the standup thread daily
- Retrieve recent replies using
conversations.replies - Parse messages to extract ticket links, status keywords, or blocker flags
- Query Linear and Jira for referenced issue updates
- Fetch OOO status from Google Calendar
What the Agent Decides
- Determine if an update:completes the prompt requirements: yesterday, today, blockers
- Judge if status claims match actual ticket progress
- Summarize and group updates, distinguishing blockers from progress
- Flag inconsistencies or vague updates for human review
What Needs Human Approval
- Asking follow-up questions in cases of ambiguous or partial standup updates
- Marking a blocker as critical for escalation
- Overriding summary content if needed
Worked Example: Walking Through One Record
Let’s use a real-looking example for an engineering team’s async standup in Slack:
- Standup thread started at 9:00 AM in #standup-engineering
- Three team members reply
Reply 1 (Alicia):
Yesterday: Shipped user profiles (Linear PRJ-823). Today: On bug fixes (Jira ENG-550). Blocked: Waiting for UI review.
Reply 2 (Ben):
Wrapping up email integration. Jira ticket ENG-543. No blockers.
Reply 3 (Devon):
Out sick. Skipping today.
Processing These Records
Code:
- At 10:00 AM, code calls
conversations.replieson the thread parent message in #standup-engineering. - For each reply, extracts names, dates, and any referenced issues (PRJ-823, ENG-550, ENG-543).
- Using Slack-to-Linear/Jira user mapping, queries issue status for PRJ-823, ENG-550, ENG-543.
- Checks Google Calendar for Devon: sees "Out Sick" event.
Agent Judgment:
- Confirms Alicia referenced work completed (Linear PRJ-823:
state = completed) and today's focus (Jira ENG-550:status = In Progress). Flags "Waiting for UI review" as a blocker and checks if UI reviewer is assigned. - For Ben: verifies ENG-543 is assigned, nearing completion. "No blockers" is consistent with ticket info.
- For Devon: cross-checks calendar OOO status, marks as excused absence.
Summary Construction:
- Groups updates by team member, including yesterday/today/blocker sections
- Adds context about blockers (e.g., "UI review pending with Casey")
- Flags any unaddressed blockers by mention
- Avoids copying extraneous Slack text
Output to Slack:
Using chat.postMessage, agent posts a single message summary at 10:15 AM:
**Daily Standup Summary***Alicia*: - Completed Linear PRJ-823 (user profiles)- Today: Jira ENG-550 (bug fixes)- **Blocked**: Waiting for UI review by @casey*Ben*: - Wrapping up Jira ENG-543 (email integration)- No blockers*Devon*: - OOO: Out Sick
If a blocker lingers or an update seems mismatched (e.g., ticket status unchanged), the agent can flag in the summary, or ping the individual privately for clarification.
Building It on Major
You will use each construct in Major:
App: Code and State
- App logic: Schedules daily runs, fetches Slack replies using
conversations.replies, parses and canonicalizes updates - Connectors: Authenticated access to Slack, Google Calendar, Linear, Jira, using scoped credentials
- State: Stores mapping of Slack user IDs to Linear and Jira users; tracks past standup times and message IDs
Agent: Judgment and Summarization
- Agent flow: Reads parsed standup entries and cross-references ticket activity
- Evaluation: Determines if the reply satisfies standup expectations, flags missing fields, interprets blockers
- Summarization: Writes human-readable team summary, flags issues, assigns mentions
- Escalation: Requests human intervention for ambiguous updates or when a defined blocker threshold is crossed
Workflow: Orchestration and Approvals
- Trigger: At scheduled hour (say, 10:00 AM), or after all participants have replied
- Orchestration: Kicks off app to gather & parse data, then agent summarizes, then posts output
- Approvals: If a blocker needs escalation, request approval from team lead before final posting
- Audit Logging: Each action logged, scoped to the agent’s run
What to Measure
Key metrics to track for a slack daily standup summary agent:
- Participation rate: Number of replies compared to expected participant list
- Blocker discovery rate: % of standups correctly flagging and escalating blockers
- Agent/human handoff rate: How often a human override or clarification is required
- Summary accuracy: Spot check summaries versus original replies for accuracy
- Elapsed time: Time from standup thread open to summary post
Tracking these helps identify reliability, gaps, and ongoing process fit.
Guardrails
Agents must never:
- Summarize private or direct messages outside the intended standup thread
- Post directly to high-visibility channels without team lead approval in case of sensitive blockers
- Make assumptions about work state not supported by Linear, Jira, or explicit calendar events
- Rewrite updates in a way that changes member intent or context
- Overwrite or redact messages already posted by team members
- Access or store credential scopes not explicitly permitted per connector
- Post summaries if data collection is incomplete or ambiguous
Frequently asked questions
How does the agent handle missing or late standup replies?
The agent checks the Slack thread for all expected participants. If a reply is missing, it cross-checks Google Calendar for OOO status. It can flag missing updates in the summary or prompt the user directly. Human intervention is requested if absence cannot be confirmed automatically.
What if a blocker reported in Slack conflicts with ticket status in Jira or Linear?
The agent tries to match reported blockers with the ticket's current status and comments. If there is a discrepancy, such as a blocker that is not reflected in the ticket system, the agent flags it for human review before posting the summary.
Which Slack API endpoints are used in the process?
The core Slack endpoints involved are conversations.replies (to get standup thread replies), chat.postMessage (to send the summary), and occasionally users.info (to map Slack user IDs).
Can the agent handle standups across multiple projects or squads?
Yes, the process can be configured for multiple Slack channels or threads. Each thread corresponds to a team or squad. The agent maps members to projects in Linear or Jira, collecting and summarizing updates per group.
Start building on Major
Connect Slack, describe the process, and Major builds the app that holds its state, the agent that makes the judgment call and the workflow that runs it, with scoped access and an audit log from the first deploy.
Frequently asked questions
- How do Slack AI agents work with Major?
- Slack AI agents in Major use API methods to read and post messages, summarize conversations, and trigger workflows. They hold app state, request approvals, and integrate Slack data into wider business processes.
- Can I automate cross-tool workflows that include Slack?
- Yes, Major enables Slack data to trigger actions across your connected business tools and vice versa. Workflows can read, write, and summarize Slack messages as part of multi-system automation.
- Do I need to replace Slack to use Major?
- No. Major orchestrates workflows in and around Slack. Slack remains your organization's conversation platform, while Major adds orchestration, automation and audit.
- Which Slack API endpoints do AI agents use most often?
- Common endpoints include `chat.postMessage` for posting to channels, `conversations.history` for reading messages, and channel management using `conversations.create` and `conversations.list`.
- How does authentication work for Slack automation in Major?
- Authentication requires creating a Slack app, installing it to your workspace, and providing OAuth scopes. API requests use an OAuth 2.0 bearer token in the Authorization header.