Grain — every page in one document

Grain is a multi-agent command center. One operator delegates work to a coordinated swarm of specialized AI agents — Scout, Closer, Shield, Spark, Atlas, Pulse, Beacon, Forge, Sentinel, Scribe — that draft deliverables, run integrations, and post results back into whichever channel asked.

This page covers the full product end-to-end. If you're skim-reading, the Quick start gets you live in 10 minutes.

Quick start (10 minutes)

1. Create your workspace

Sign up at app.grain.sh. Pick a workspace name. You're in. No credit card required for the 30-day trial.

2. Install the desktop companion app

The desktop app runs your local executor — the process that picks up tasks and runs them on your machine (using your Claude Code / Codex / Gemini install). Tasks queue in Grain's cloud, but execution happens locally where your data lives.

• macOS Apple Silicon: Grain-latest-mac-aarch64.dmg
• macOS Intel: Grain-latest-mac-x64.dmg
• Windows / Linux: coming soon — for now run the executor via npm run executor from a checkout

Install, launch, sign in with the same account. See grain.sh/download for all builds and SHA256 sums.

3. Connect Slack

In Grain → Settings → Integrations → click the Slack tile → Connect → approve on slack.com.

In Slack: /invite @Grain in any channel where you want the bot to listen.

4. Spawn your first task

In Slack:

@Grain summarize the last 24 hours in this channel

A live progress card appears within ~2 seconds and updates in place as the agent works. When done, the deliverable posts in the same thread.

How Grain works

┌──────────────────────────────────────────────────────────┐
│ You (Slack / web / desktop / iOS)                        │
└─────────────────────────┬────────────────────────────────┘
                          │ @Grain mention · Ask AI · API
                          ▼
┌──────────────────────────────────────────────────────────┐
│ Convex backend (cloud)                                   │
│ • Receives mention                                       │
│ • Routes to agent (delegator / explicit @scoped / RAG)   │
│ • Creates task row                                       │
│ • Posts live progress card                               │
└─────────────────────────┬────────────────────────────────┘
                          │ task.status = "in_progress"
                          ▼
┌──────────────────────────────────────────────────────────┐
│ Local executor (your desktop)                            │
│ • Polls every 5s for tasks assigned to its agents        │
│ • Spawns Claude Code / Codex / Gemini / Superagent       │
│ • Streams tool-call events back                          │
│ • Submits final result                                   │
└─────────────────────────┬────────────────────────────────┘
                          │ result + cost + artifact
                          ▼
┌──────────────────────────────────────────────────────────┐
│ Convex backend (cloud)                                   │
│ • Updates task status                                    │
│ • Posts completion card back to Slack thread             │
│ • Persists Frame artifact                                │
│ • Debits cost from credits ledger                        │
└──────────────────────────────────────────────────────────┘

Why this split?

Your code, files, and credentials stay on your machine. Grain's cloud only sees task metadata (title, status, cost) — never the contents the agent reads or writes. You bring your own LLM keys, you run the agent loop locally, you keep the data.

The 10 named agents

Each agent has a role, a persona file (SOUL.md), and a set of attached skills. You can edit personas, route tasks to specific agents, or let the delegator pick.

Routing

• Default: Grain's delegator analyzes the request and routes to the best-fit agent.
• Scoped: @Grain ATLAS draft a Q3 review → goes directly to Atlas.
• Project-pinned: tasks created inside a project default to that project's preferred agent.

Editing personas

Settings → Agents → click an agent → Persona editor. Each agent has a SOUL.md — global personality + tone. Per-project AGENT.md overlays add project-specific context.

You are Spark — Grain's marketing agent.
Voice: confident, witty, never cute.
Always include one tasteful dry observation per draft.
Default to short paragraphs and bulleted lists over walls of text.

Slack integration

The Slack bot is Grain's primary surface for most users. Full feature set:

@Grain mention flows

Routing confirmation

When you say “create a task,” Grain doesn't just spawn one — it asks:

• ⚡ Quick reply — gpt-4o-mini, inline reply in ~2s, no task row, no executor. Costs ~$0.0001. Good for “draft an email,” “summarize last week's standup.”
• 🤖 Send to agent — creates a real task, runs the full agent pipeline on your executor, progress streams back to the thread, deliverable posts when done. Good for “research competitors,” “build a battlecard,” “review the codebase.”

Long requests (>800 chars) skip the confirmation and go straight to agent — clearly not a quick-answer at that size.

Thread continuation

Reply in any thread Grain opened — your text appends to the running task's conversation. The agent picks up the new context on its next round. No need to switch to the web app.

Channel monitoring (opt-in)

In Settings → Integrations → Slack → Monitored channels, tick channels like #bugs or #support. Grain passively classifies every top-level message via gpt-4o-mini:

• Looks like a bug → posts a card: “🐛 File this in Linear?” with ✅/❌
• Looks like a feature request → same flow but tagged Feature
• Looks like noise → silent

Click ✅ → real Linear issue created with title, body, priority, type, link back to the Slack thread.

Cost: ~$0.0001 per message classified. Default OFF for every channel — opt in per channel.

Strict @mention policy

Grain is silent in channels unless explicitly tagged. No autonomous task creation from random chatter. Three paths to act:

• @Grain mention — always responds
• Thread reply to a Grain-started thread — appends to that task
• Monitored channel (you opted in) — classifier fires on top-level messages

Everything else: ignored.

Installation (manual fallback)

If your org doesn't have SLACK_CLIENT_ID configured (rare — only for self-hosted Grain), follow the manual setup. We provide a paste-ready manifest at docs/slack-app-manifest.yaml — paste at api.slack.com/apps → From a manifest. Then add the redirect URL https://app.grain.sh/api/slack/callback and paste the Bot Token + Signing Secret in Settings.

Other integrations

Native — built by Grain, one-click OAuth

Each tile in Settings → Integrations has Connect / Manage / Disconnect with a confirmation dialog. Disconnect is a full teardown — revokes the OAuth token, disables the tools, stops notifications.

Community long-tail — via Composio

3,200+ apps available through Composio. Toggle on toolkits (Mailchimp, Trello, Calendly, Zoho, etc.) in Settings → Integrations. First-time use opens app.composio.dev/apps for OAuth on Composio's hosted page; subsequent calls just work.

MCP servers (advanced)

Add custom MCP servers from the public catalog or your own self-hosted ones at Settings → MCP Catalog. Run any stdio / SSE / streamable-http server alongside Grain's native tools.

Notification channels

Tasks & execution

Task lifecycle

backlog → todo → in_progress → testing → review → done

Most tasks skip straight from creation to in_progress (executor picks up immediately). The intermediate states are for tasks that require human approval gates or have explicit testing phases.

How execution works

When a task hits status: "in_progress":

• Local executor (running on your desktop) polls every 5s for assigned tasks
• Picks the right backend per agent config: claude-code, codex, gemini, superagent, or auto
• Spawns the backend CLI with your env keys
• Streams tool-call events back via /api/executor/result
• Submits final deliverable + cost

Backend selection

Set per-agent in Settings → Agents → Backend, or per-task via the task creation form.

Approval gates

Tasks can require human approval before they finish. Common patterns:

• Plan approval — agent posts a plan, waits for ✅ before executing
• Decision approval — agent finishes, posts a deliverable, waits for ✅ before marking done
• Risky-action approval — agent flags dangerous actions (file deletion, PR merge, etc.) inline

Approvals appear in Slack, the web app's Approvals tab, the iOS app, or via email.

Parallel multi-engine racing

Optional — enable in Settings → Execution. Grain runs your task on multiple backends simultaneously (Claude Code + Codex + Gemini) and ships the first acceptable result. Costs more but cuts time-to-deliverable by ~40%.

Server-side fallback

When your local executor has been silent for >60s, a server-side fallback executor takes over. Uses your ANTHROPIC_API_KEY (or OPENAI_API_KEY). Configure in Settings → AI → Execution Engine → Cloud fallback.

Frames — shareable artifacts

Frames are Grain's shareable artifact format. Every agent deliverable that isn't pure text is rendered as a Frame:

• Brief — research memos, competitive battlecards, exec summaries
• Dashboard — block-based data widgets (KPIs, charts, tables)
• Report — weekly recaps, scheduled outputs, recurring summaries
• Memo — long-form analysis with sections + citations
• Battlecard — sales objection-handling, win/loss patterns

Each Frame has

• A canonical URL (app.grain.sh/briefs/<id>)
• PDF export for offline sharing
• Share token for read-only public links (no auth required)
• Embed widget for dropping into Notion, Confluence, your own site

Frames render the same way everywhere — Slack file deliverable, email attachment, web view — because they're all served from one Frame source.

Settings reference

The Settings page is organized into seven left-rail tabs. Deep-link any of them via the URL path, e.g. app.grain.sh/settings/ai.

AI & Models — /settings/ai

• Execution Engine — pick the default LLM provider, set BYO API keys (Anthropic, OpenAI, Google, etc.)
• Smart Task Routing — rules that route specific task types to specific models
• Model Triage — fallback chain when primary model is rate-limited
• Retry Escalation — auto-upgrade to a stronger model on retry
• AI Intelligence — quality gates, confidence thresholds, auto-iteration caps

Agents & Skills — /settings/agents

• Agent Tools (MCP) — add MCP servers, configure per-agent tool access
• Superagent (beta) — opt-in Hermes runtime for persistent continuous agents

Execution — /settings/execution

• Execution Backend — set per-agent backend (claude-code / codex / gemini / superagent)
• Parallel Multi-Engine — toggle racing
• Superpowers — enable cross-task memory, skill auto-creation
• Gstack — Grain-native code execution sandbox (E2B)

Workspace — /settings/workspace

• Git Configuration — repos agents can clone, branch naming rules
• Custom Branding — your logo, color palette, fonts (shown in Frames + Slack cards)

Knowledge — /settings/knowledge

• Knowledge Base — internal wiki entries agents read at task start
• Connected Sources — RAG-indexed sources (Notion, Google Drive, Slack history, etc.)

Automation — /settings/automation

• Scheduled Reports — recurring agent tasks (weekly metrics, daily standups, monthly summaries)
• Notification Settings — which events route to which channels

System — /settings/system

• Environment Variables — per-org env vars exposed to the executor
• Mobile Access — iOS app pairing
• API Tokens — for programmatic Grain access

Pricing

All plans: 30-day free trial, no card required. Annual billing saves 20%. See grain.sh/pricing for the full breakdown.

Security & data

Where your data lives

• Task metadata + agent state — Convex backend (cloud)
• Agent execution — your local desktop (default) or our server fallback (opt-in)
• Code, files, credentials the agent reads — your machine, never leaves
• LLM API calls — your BYO keys or Grain's pooled keys (your choice)

Authentication

• Email + password (default)
• Google OAuth
• SSO / SAML (Enterprise)
• 2FA available on all plans

Audit

• Every agent action logged with timestamp, user, agent ID, tool call, cost
• Costs Dashboard breaks down by agent / task / provider / day
• ROI Dashboard correlates agent output to business outcomes

Compliance

• SOC 2 Type II (in progress, targeting Q4 2026)
• GDPR-compliant data handling
• Per-org data residency (Enterprise)
• No training on customer data — your prompts + outputs never feed model training

FAQ

Why local execution? Isn't cloud easier?

Because your code, customer data, and credentials are too sensitive to leave your machine. Grain's cloud orchestrates the work — your machine does the work. You get the convenience of a SaaS task manager with the privacy of self-hosted execution.

Can I use Grain without a desktop app?

Yes — toggle on cloud fallback in Settings. Server-side executor picks up tasks when your desktop is offline. Uses your BYO API key.

Which LLM is best?

Depends on the task. Smart Task Routing picks for you. Defaults:

• Slack quick-answer: OpenAI gpt-4o-mini
• Long agent tasks: Claude Sonnet 4.5 via Claude Code CLI
• Massive-context research: Gemini 2.5 Pro

Can I bring my own model?

Yes via OpenRouter or any OpenAI-compatible endpoint. Set in Settings → AI → Custom Provider.

How do I get Grain on my phone?

iOS app in beta — pair via Settings → Mobile Access on the web app. Android app shipping Q3 2026. In the meantime, mobile Slack works perfectly — every Grain interaction is available there.

What happens if I cancel?

Your workspace stays read-only for 90 days. Export all tasks, Frames, and chat history via Settings → Workspace → Export. After 90 days, data is permanently deleted.

Self-hosted option?

Yes for Enterprise. Run Grain on your own Convex deployment, your own infrastructure. We provide the Docker Compose stack + ops support.

Get help

• Status page: status.grain.sh
• Community Slack: grain-community.slack.com
• Email support: support@grain.sh
• Enterprise: enterprise@grain.sh