How we run async standups in Slack
A daily agent that collects each person's Linear and GitHub activity, prompts anyone with nothing recorded, and posts a concise team standup to Slack. Read-only across every tool.
A standup is supposed to answer one question: what did everyone do, and what's next. In practice it costs a meeting, or a thread where half the team pastes a summary and the other half forgets. The information already exists in Linear and GitHub; someone just has to gather it, format it, and chase the people who didn't post.
We run a daily agent on Kortix that does the gathering. It reads each person's Linear and GitHub activity, nudges anyone with nothing recorded, and posts a concise standup to a Slack channel. This is how we run our own standups, and the same setup works for any team.
The problem
A live standup takes a slot on everyone's calendar to relay information that's already recorded somewhere. An async thread saves the meeting but shifts the work onto people: each person has to remember to write, summarize their own day, and post it, and the ones who don't leave gaps.
The common workarounds are partial. A recurring bot that asks "what did you do yesterday?" still depends on everyone answering. A dashboard shows activity but doesn't summarize it or tell you who's quiet. Neither reads the tools where the work actually happened, so the summary is only as complete as the people filling it in.
What we built
On Kortix, a cron fires once each weekday morning and spawns an agent. It reads each team member's recent Linear issues and GitHub activity, builds a short per-person summary, checks who has nothing recorded, and posts the standup to a Slack channel. Anyone with a quiet day gets a light prompt so they can add context the tools can't see. The agent only reads; it never writes to Linear or GitHub.
How it works
Trigger it on a daily cron
The standup runs on a cron trigger: once every weekday morning, the schedule spawns a fresh session in its own isolated sandbox. One run, one disposable machine, nothing carried over from the day before. No one has to start it and there's no bot sitting idle waiting for messages.
Give the agent the team and the format
Who's on the team, which repos and Linear projects to look at, and what a good standup entry looks like live as skills and memory that travel with the agent: the roster, the mapping from a person to their Linear and GitHub handles, and the house style for a summary. When the format changes, we update the file and the next run picks it up.
Connect Linear and GitHub, read-only
Through scoped connectors, brokered server-side so no raw token reaches the model, the agent reads:
- Linear — each person's recently updated and closed issues, and what's in progress.
- GitHub — commits, opened and merged PRs, and reviews since the last standup.
Both connectors are scoped to read only. The agent can see the activity; it cannot change an issue or touch a branch.
Set the guardrails
The agent is read-only across Linear and GitHub by design: its only write is the Slack post. It doesn't move tickets, comment on PRs, or edit anyone's work. Credentials are encrypted in the Secrets Manager and injected at runtime, never shown to the model or written to logs.
Post the standup and prompt the gaps
With that in place, the morning post writes itself: a per-person summary drawn from Linear and GitHub, grouped so the team can scan it in one read. Anyone with no recorded activity is flagged with a gentle prompt to add what the tools missed, meetings, planning, anything off-platform, so a quiet day shows context rather than a blank line.
The pattern
A cron trigger spawns a session each morning with read-only connectors into Linear and GitHub. The roster and format live as skills and memory. The agent summarizes, prompts the gaps, and posts to Slack, its only write.
Guardrails
The agent reads everyone's activity across two tools and posts to a shared channel, so the access is scoped and contained:
- Isolation. Every run happens in its own microVM sandbox. The session reads the day's activity, builds the summary, and only the Slack post leaves the sandbox.
- Scoped secrets. The Linear, GitHub, and Slack credentials are encrypted in the Secrets Manager and injected into the sandbox at runtime, never exposed to the model or the logs.
- Read-only across the tools. The Linear and GitHub connectors are scoped to read. The agent's only write is the standup post; it changes nothing in the source tools.
- Everything is code. The roster, the format, and the per-tool permissions are files in the repo, versioned and changed through a reviewed change request rather than a dashboard setting.
The outcome
The standup now arrives each morning as a Slack post built from the work people already recorded, with quiet days flagged instead of skipped. No one spends a meeting relaying status, and no one has to write their own summary for the activity the tools already have.
Read more
How we keep our docs in sync with the code
The docs agent we run on Kortix — connected to GitHub and our codebase. Once a day it checks the code that landed since its last run and updates the docs those changes affected, opening a PR for review.
How we QA every pull request automatically
The QA agent we run on Kortix — connected to GitHub and our test environment. It checks out each PR, runs the suite, exercises the change, and posts the result.
How we run operations from Slack
A single agent reachable from Slack, with scoped access to our database, Stripe, Linear, and GitHub. Ask in a thread and it runs the task across whatever platforms it needs.
Engineer your first loop
Give your company a workforce of agents that run on a schedule, ship real deliverables, and improve one reviewed change at a time. Free to self-host, managed cloud from $20.
Open source · SSO · RBAC · on-prem · no lock-in