Build a GitHub-to-Slack Development Digest with Agent Canvas

Overview

Developers spend a lot of time on small recurring loops: reviewing labeled pull requests, answering GitHub comments, triaging new issues, turning Slack threads into standup notes or incident follow-ups, and tracking release or research signals. Each loop is familiar, but it still requires judgment: gather the right context, decide what matters, and post a clear update where the team already works.

OpenHands automations turn those loops into scheduled or event-triggered agent conversations: runs where an AI software agent can read context, call tools, and produce an update. The shared automation templates in the OpenHands extensions catalog follow this pattern for GitHub pull request review, repository monitoring, Linear issue triage, incident retrospectives, Slack standup digests, and research briefs: an automation wakes up, uses configured integrations such as GitHub or Slack to fetch context, reasons over that context with a large language model (LLM), and writes back a result.

Agent Canvas is the local control plane for building and testing those automations. In this playbook it runs an OpenHands Agent Server, the backend process that executes agent conversations, and connects the agent to external services such as GitHub and Slack.

To keep the workflow on your AMD system, the agent talks to a local model served by Lemonade Server. Lemonade exposes that model through an OpenAI-compatible API, so Agent Canvas can configure it like a remote OpenAI-style endpoint while the model, prompt, and workflow context stay local.

In this playbook, you will build one concrete automation: a scheduled GitHub-to-Slack development digest. It uses GitHub to inspect recent repository activity, Slack to post the digest, Agent Canvas API calls to configure and test the automation, and Lemonade to run the LLM locally.

What You’ll Learn

• How to start Lemonade Server and verify a local model answers chat requests
• How to launch Agent Canvas and point its Agent Server at a local LLM
• How to install GitHub and Slack Model Context Protocol (MCP) servers through the Agent Server API
• How to create and dispatch a scheduled OpenHands automation that posts a development digest to Slack
• How to troubleshoot the most common local-model and automation failures

Core Concepts

Setting the Memory Configuration

sudo apt install pipx
pipx ensurepath

pipx install amd-debug-tools

amd-ttm

amd-ttm --set <NUM>

Prerequisites

msiexec /i lemonade-server-minimal.msi /qn

sudo add-apt-repository ppa:lemonade-team/stable
sudo apt install lemonade-server

yay -S lemonade-server

lemonade --version

lemonade version x.y.z

node --version
npm --version

curl -o- https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh | bash

# Download and install Node.js:
brew install node@22

# Verify the Node.js version:
node -v # Should print "v22.22.1".

# Verify npm version:
npm -v # Should print "10.9.4".

msiexec /i lemonade-server-minimal.msi /qn

sudo add-apt-repository ppa:lemonade-team/stable
sudo apt install lemonade-server

yay -S lemonade-server

lemonade --version

lemonade version x.y.z

You need:

• Lemonade Server installed by following the standard Lemonade installation guide.

• A GitHub token with read access to the repository you want summarized.
• A Slack bot token (xoxb-...) with chat:write and channel read access.
• A Slack team ID (T...).
• A Slack channel ID (C...) where the digest should be posted.

Invite the Slack app to the target channel before testing the automation.

Variables Used in This Playbook

export LEMONADE_BASE_URL="http://127.0.0.1:13305/api/v1"
export LEMONADE_MODEL="Qwen3.6-35B-A3B-GGUF"

$env:LEMONADE_BASE_URL = "http://127.0.0.1:13305/api/v1"
$env:LEMONADE_MODEL = "Qwen3.6-35B-A3B-GGUF"

These two variables are used by the verification commands below. The model, tokenizer, and other LLM settings are entered directly in the Agent Canvas UI in later steps, so their literal values are shown inline where you need them.

The following values are entered into the Agent Canvas UI in later steps. Set them here so you can copy them in:

export GITHUB_REPO_FILTER="your-org/your-repo"
export SLACK_DIGEST_CHANNEL="C0123456789"
export DIGEST_TIMEZONE="America/New_York"

$env:GITHUB_REPO_FILTER = "your-org/your-repo"
$env:SLACK_DIGEST_CHANNEL = "C0123456789"
$env:DIGEST_TIMEZONE = "America/New_York"

Use an explicit owner/repo value for GITHUB_REPO_FILTER. Broad organization wildcards can return too much MCP context for local models.

1. Start Lemonade Server

Start the model from the Lemonade CLI:

lemonade config set llamacpp.backend=vulkan
lemonade config set ctx_size=65536
lemonade run "${LEMONADE_MODEL}"

lemonade config set llamacpp.backend=vulkan
lemonade config set ctx_size=65536
lemonade run "$env:LEMONADE_MODEL"

Choose a model that fits your hardware. Qwen3.6-35B-A3B-GGUF (~20 GB) is a strong model for this workflow but needs a large memory pool. If your device has limited memory or GPU VRAM, pick a smaller GGUF model from the Lemonade model library and use that model ID (and its matching tokenizer) throughout this playbook.

Lemonade exposes an OpenAI-compatible API at:

http://127.0.0.1:13305/api/v1

Optional: if Agent Canvas or the automation runner is not on the same machine, publish the Lemonade endpoint through a secure tunnel and use the HTTPS URL as the LLM base URL. ngrok exposes a local port to the internet over a secure HTTPS URL; it requires a free ngrok account, and you replace YOUR_NGROK_DOMAIN.ngrok-free.dev with your own reserved domain:

ngrok http 13305 --url YOUR_NGROK_DOMAIN.ngrok-free.dev

2. Verify the Local Model

Confirm Lemonade can serve the selected model:

curl -s "${LEMONADE_BASE_URL}/models" | python3 -m json.tool

curl -sS "${LEMONADE_BASE_URL}/chat/completions" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"${LEMONADE_MODEL}"'",
    "messages": [
      {"role": "user", "content": "Reply with exactly: OK"}
    ],
    "temperature": 0,
    "max_tokens": 64
  }' | python3 -m json.tool

curl.exe -s "$env:LEMONADE_BASE_URL/models"

$body = @{
  model    = "$env:LEMONADE_MODEL"
  messages = @(@{ role = "user"; content = "Reply with exactly: OK" })
  temperature = 0
  max_tokens  = 64
} | ConvertTo-Json -Depth 5
curl.exe -sS "$env:LEMONADE_BASE_URL/chat/completions" -H "Content-Type: application/json" -d $body

If this returns a choices array, Lemonade is ready for Agent Canvas.

3. Start Agent Canvas

npm install -g @openhands/agent-canvas
agent-canvas

$env:PROJECTS_PATH = Join-Path $HOME "projects"
New-Item -ItemType Directory -Force -Path $env:PROJECTS_PATH, (Join-Path $env:USERPROFILE ".openhands") | Out-Null

docker pull ghcr.io/openhands/agent-canvas:1.14.0

docker run -it --rm `
  -p 8000:8000 `
  -v "$($env:USERPROFILE)\.openhands:/home/openhands/.openhands" `
  -v "$($env:PROJECTS_PATH):/projects" `
  ghcr.io/openhands/agent-canvas:1.14.0

4. Configure the Local LLM in the UI

On first launch, Agent Canvas opens an onboarding flow. In that flow:

1. Keep OpenHands selected as the agent and click Next.
2. On Set up your LLM, select Advanced.
3. Keep Authentication set to API key.
4. Set Custom Model to openai/Qwen3.6-35B-A3B-GGUF.
5. Set Base URL to http://127.0.0.1:13305/api/v1.
6. For API Key, enter any non-empty placeholder such as lemonade-local. Lemonade does not require a real key, but the OpenHands client needs a value to send.

The connection fields should look like this. The API key field is masked by the UI.

Then select All and set the extra local-model fields:

1. Scroll to Custom Tokenizer and set it to Qwen/Qwen3.6-35B-A3B.
2. Scroll to LiteLLM Extra Body and set it to {"enable_thinking": true}.
3. Click Next.

The LLM settings should show:

The openai/ prefix tells LiteLLM to use OpenAI-compatible request formatting against the Lemonade endpoint. The custom tokenizer is the original Hugging Face tokenizer for the GGUF model; it lets OpenHands count the same chat-template tokens that the local model server sees. The current first-use LLM form does not show condenser settings. If your Agent Canvas build exposes condenser settings later under Settings > LLM, use llm_summarizing and set max tokens below the Lemonade context window, such as 56000.

5. Install GitHub and Slack MCP Servers

In the Agent Canvas UI, open Customize (or Settings > MCP) to add the MCP servers that give the agent tools for GitHub and Slack. Token values are sent only to your local Agent Server and are persisted as encrypted settings.

GitHub MCP server

Add a new MCP server with these settings:

Use a GitHub token with read access to the repository you want summarized.

Slack MCP server

Add a second MCP server with these settings:

Set SLACK_CHANNEL_IDS to the digest channel ID (the same value as SLACK_DIGEST_CHANNEL) so the agent does not need to page through every Slack channel.

After adding both servers, use the Test button on each one to confirm it connects and advertises tools. The GitHub server should list GitHub tools, and the Slack server should list Slack tools.

6. Create the Digest Automation

In the Agent Canvas UI, open the Automations page and create a new automation:

1. Choose Create automation and select the Prompt preset type.
2. Set the Name to GitHub Development Digest to Slack.
3. Set the Prompt to the following text, replacing the repository and channel placeholders with your values:

Use the GitHub MCP server for exactly one repository: your-org/your-repo.
Inspect recent development activity since the previous weekday, including
merged pull requests, newly opened or reopened pull requests, notable
commits pushed to main or release branches, new issues, important issue
updates, releases, risks, blockers, and review requests. Keep GitHub
lookups small: inspect the latest 3 to 5 commits, pull requests, issues,
and releases. Use the Slack MCP server to post directly to channel ID
C0123456789. Keep the Slack message concise: title with date range, 3 to 7
bullets, links back to GitHub, and a Needs attention section only if
needed. End with: This digest was generated by an AI agent (OpenHands) on
behalf of the user. Do not include secrets, raw tokens, private
environment variables, or unrelated Slack messages.

4. Set the Trigger to Cron with the schedule 0 9 * * 1-5 (9 AM on weekdays) and set the Timezone to your timezone, for example America/New_York.
5. Set the Timeout to 900 seconds.
6. Save the automation.

The automation detail page shows the new automation with its cron trigger and the generated prompt-preset entrypoint.

7. Test the Automation

From the automation detail page in the Agent Canvas UI:

1. Click Run now (or Dispatch) to run the automation once immediately.
2. Watch the run list on the same page. The latest run should transition to COMPLETED.
3. Open your target Slack channel. It should contain the generated digest.

You do not need to wait for the cron schedule to fire—Run now triggers a run on demand so you can confirm the prompt, MCP connections, and Slack posting all work before relying on the schedule.

Troubleshooting

• Lemonade is down: restart it with the lemonade run "${LEMONADE_MODEL}" command in step 1, then re-run the health check.
• npm install -g fails with a permissions error: on Linux or WSL, configure a user-owned global npm directory, add it to your shell startup file, then install Agent Canvas again:

mkdir -p ~/.npm-global
npm config set prefix "$HOME/.npm-global"
printf '\nexport PATH="$HOME/.npm-global/bin:$PATH"\n' >> ~/.bashrc
export PATH="$HOME/.npm-global/bin:$PATH"
npm install -g @openhands/agent-canvas

If you use zsh, add the same export PATH=... line to ~/.zshrc instead of ~/.bashrc.

• Agent Canvas rejects the LLM settings after setting custom_tokenizer: install transformers in the Agent Server Python environment, restart Agent Canvas if needed, and retry saving the LLM settings. OpenHands requires Transformers to load the tokenizer chat template when custom_tokenizer is set.
• Agent Canvas cannot reach Lemonade: verify curl -fsS "${LEMONADE_BASE_URL}/health" and confirm the base URL entered in the first-use LLM form or Settings > LLM matches the running local endpoint or HTTPS tunnel.
• The LLM settings did not save: make sure you clicked Next after entering the values. Reopen Settings > LLM to confirm the values persisted.
• GitHub MCP cannot see private repositories: confirm the GitHub token has read access to the target repository and that the MCP Test button in Customize advertises GitHub tools.
• Slack can read channels but cannot post: invite the Slack app to the target channel and confirm the bot has chat:write.
• The automation lists too many Slack channels: use a Slack channel ID and set SLACK_CHANNEL_IDS on the Slack MCP server in Customize.
• The automation run fails or exceeds context: confirm Lemonade was started with ctx_size=65536, confirm the OpenHands LLM has custom_tokenizer set, and use an explicit repository with GitHub result sets capped to 3 to 5 items. If your Agent Canvas build exposes condenser settings, set condenser max tokens below the Lemonade context window.

Next Steps

• Add a weekly release-only digest.
• Add a GitHub event-triggered automation for faster PR or push alerts.
• Route the same digest into Notion, Linear, or another MCP-backed tool.

Resources

• AMD AI Playbooks
• Lemonade Server documentation
• OpenHands extensions repository
• Model Context Protocol servers
• Slack MCP package