Use Cases

These are real-world setups showing ScalyClaw in action. Each scenario walks through a concrete goal, what you'll need, how to configure it, and what the experience looks like in practice. The scenarios are independent — pick the one closest to your situation and adapt it freely.

Personal Assistant

Use ScalyClaw as a daily companion that follows you across channels. You message it on Telegram in the morning and continue the same thread on Discord in the evening — the memory system ensures it never loses the thread. The assistant learns your habits, preferences, and recurring interests over time, gradually becoming more useful without any manual tuning.

What You'll Need

• A Telegram bot token (from @BotFather) and/or a Discord application with a bot token
• Your Telegram user ID or Discord user ID to set as the allowed user in the channel config
• A few minutes to write your mind/SOUL.md — the personality file that shapes tone and style
• Optionally: API keys for any skills you want to enable (weather, calendar, news)

Setup

Enable both channels from the dashboard Channels page. Set your own user ID as the only permitted user on each channel so no one else can interact with your assistant. Then open Mind and edit SOUL.md to describe the tone you want — casual or formal, brief or expansive, which topics it should prioritise.

# mind/SOUL.md — example personal tone

You are my daily companion. Keep responses concise and conversational.
I'm a software engineer who reads a lot. I care about privacy and open source.
When I ask about something technical, be precise. Otherwise be casual.
Remember my preferences without me having to repeat them.

Turn on proactive engagement in the config so the assistant can reach out when it has something worth surfacing — a saved article you haven't read, a reminder you set yesterday, a follow-up on something you mentioned.

Starter Skills

• weather-lookup — queries a weather API for your default location; the assistant learns your location from context and saves it to memory
• calendar-sync — reads upcoming events from a CalDAV or Google Calendar endpoint and formats them as a daily briefing
• news-summary — fetches RSS feeds or a news API and summarises headlines filtered to your saved interests

Cross-Channel Memory

The memory system stores facts, preferences, and conversation summaries in a shared SQLite database — not per-channel. When you switch from Telegram to Discord, the assistant picks up where you left off.

— Telegram, morning —

You:       I've been thinking about switching from Vim to Neovim.

ScalyClaw: Makes sense — the plugin ecosystem is much better now. Are you
           planning to migrate your config or start fresh?

→ memory write: "user considering Neovim migration"

— Discord, evening —

You:       What's a good Neovim starter config?

ScalyClaw: You mentioned on Telegram earlier that you're considering a move
           from Vim. For a clean start, kickstart.nvim is the most popular
           base — it installs lazy.nvim and gives you a commented config
           you can strip down to exactly what you need.

Setup Checklist

• Enable Telegram and/or Discord in the dashboard Channels page
• Set your user ID as the only permitted user on each channel
• Edit mind/SOUL.md with your preferred tone and context
• Enable proactive engagement in the config
• Install one or two starter skills (weather, calendar, or news)
• Set any required API keys via the Vault page in the dashboard

Developer Companion

Use ScalyClaw as a coding-focused assistant that can read your filesystem, execute code, browse documentation, and delegate deep research to a specialist agent. This setup pairs best with a coding-optimised model (such as a model from the Claude 3.5 Sonnet or GPT-4o family) and MCP servers that give the assistant direct access to your codebase and version control.

What You'll Need

• Web Gateway enabled (for browser-based access) or Discord for a persistent chat surface
• An MCP filesystem server pointed at your working directory
• An MCP GitHub server with a personal access token for repository operations
• A "researcher" agent configured with web search permissions and a longer maxIterations
• Optionally: skills for code review automation, dependency auditing, and deploy scripts

Setup

Open the dashboard MCP page and add two servers. The filesystem server gives the assistant read and write access to a directory you specify — point it at your project root or a dedicated workspace. The GitHub server lets it open issues, read pull requests, and inspect commit history without leaving the conversation.

// Dashboard → MCP → New Server (filesystem)
{
  "name": "filesystem",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]
}

// Dashboard → MCP → New Server (GitHub)
{
  "name": "github",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-github"],
  "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." }
}

Next, open the Agents page and create a "researcher" agent. Give it a system prompt focused on thoroughness over speed, set the model to a capable reasoning model, allow it the web_search and execute_code tools, and set maxIterations to something generous (30–50). The main orchestrator can delegate long research tasks to this agent while continuing to respond to you immediately.

Codebase Analysis Example

With the filesystem MCP connected and the researcher agent in place, you can ask the assistant to explore an unfamiliar project and get a substantive report — not just a summary of the README.

You:       Analyse the auth module in /home/user/projects/myapp and tell me
           what session strategy it uses and whether there are any obvious
           security gaps.

ScalyClaw: I'll delegate this to the researcher agent — it'll do a thorough
           pass. Give me a moment.

→ delegate_agent called: "researcher"
  → mcp_call: filesystem/read_file src/auth/session.ts
  → mcp_call: filesystem/read_file src/auth/middleware.ts
  → mcp_call: filesystem/list_directory src/auth/
  → execute_code: parse JWT claims, check algorithm
  → 12 iterations, 4 files read

ScalyClaw: The auth module uses JWT with HS256. Here's what the researcher found:

           1. Sessions are stateless — no server-side revocation. If a token
              is stolen, it remains valid until expiry (currently 7 days).
           2. The secret key is read from process.env.JWT_SECRET with no
              fallback check — the app will silently accept unsigned tokens
              if the env var is missing in some environments.
           3. There is no refresh token mechanism; forced re-login is the
              only recovery path.

           Recommended fixes: add a token blocklist in Redis for logout,
           assert JWT_SECRET is set at startup, and shorten expiry to 1 hour
           with a refresh token flow.

Developer Skills

• code-review — runs a linter and static analyser on a file or diff and formats the output as structured feedback
• dep-check — reads a package.json or requirements.txt and checks for known CVEs via an advisory database API
• deploy — wraps a deploy script with pre-flight checks and posts the result back to the conversation

Setup Checklist

• Enable Web Gateway or Discord as the primary channel
• Set the main orchestrator model to a coding-capable model in the config
• Add MCP filesystem server pointing at your project directory
• Add MCP GitHub server with a personal access token
• Create a "researcher" agent with generous maxIterations and a focused system prompt
• Install code-review, dep-check, and deploy skills as needed
• Store API keys and tokens in the Vault

Team Bot

Deploy ScalyClaw into a shared Slack workspace to handle recurring team rituals — standup reminders, thread summaries, and on-demand knowledge base queries. The scheduler drives the time-based work; agents handle the heavier summarisation tasks; and a knowledge base skill gives the assistant access to your team's documentation.

What You'll Need

• A Slack app with chat:write, channels:history, and app_mentions:read scopes
• Your Slack bot token and signing secret stored in the Vault
• A standup reminder configured in the scheduler (cron, weekdays at 9am)
• A "summariser" agent with access to the Slack MCP server or a thread-reading skill
• A knowledge base skill that queries your team's docs (Notion, Confluence, a local directory, or a static site)

Setup

Enable the Slack channel in the dashboard. Add the bot to the relevant channels in your workspace. Then open the Scheduler page and create a standup reminder:

— Dashboard → Scheduler → New Schedule —

Channel:   slack:#engineering
Message:   Good morning team. Time for standup — what did you work on
           yesterday, what are you doing today, and are there any blockers?
Schedule:  0 9 * * 1-5   (weekdays at 09:00)

Create a "summariser" agent on the Agents page. Give it access to a thread-reading tool or the Slack MCP server. Team members can ask the assistant to summarise a long thread and the agent will do the heavy lifting — reading the history, distilling the key points, and posting the summary back.

Knowledge Base Skill

Write a knowledge-base skill that accepts a query string, searches your documentation source (vector search, Notion API, or a static markdown directory), and returns the most relevant excerpts. Once installed, the assistant can answer team questions grounded in your actual docs rather than general knowledge.

Engineer:  How do we handle database migrations in this project?

ScalyClaw: Let me check the docs.

→ execute_skill: knowledge-base { query: "database migration process" }
  → searched 847 docs chunks, returned top 3 excerpts

ScalyClaw: According to the engineering handbook: migrations run automatically
           on deploy via the migrate:latest npm script. Roll-backs require a
           manual down migration — see docs/migrations.md#rollback for the
           step-by-step process. Always test migrations on staging first.

Setup Checklist

• Enable the Slack channel in the dashboard
• Store the Slack bot token and signing secret in the Vault
• Create a weekday 9am standup reminder in the Scheduler
• Create a "summariser" agent with thread-reading tool access
• Install a knowledge-base skill connected to your documentation source
• Decide which Slack channels the bot joins and configure channel IDs accordingly
• Brief the team on the shared-memory model so preferences are set intentionally

Home Automation

Connect ScalyClaw to your smart home via an MCP server for Home Assistant or a similar platform. Use the scheduler to run time-based routines and enable proactive engagement so the assistant can alert you to conditions that need attention — a door left open, a temperature outside the expected range, a device that went offline.

What You'll Need

• A running Home Assistant instance with the REST API or WebSocket API enabled
• An MCP server that wraps the Home Assistant API (e.g. @modelcontextprotocol/server-home-assistant or a custom wrapper)
• Your Home Assistant long-lived access token stored in the Vault
• Proactive engagement enabled in the config, with a Telegram or Discord channel as the alert surface
• A device-status skill and a routine-runner skill

Setup

Add the Home Assistant MCP server on the dashboard MCP page. Point it at your Home Assistant URL and supply the access token via an environment variable resolved from the Vault.

// Dashboard → MCP → New Server
{
  "name": "home-assistant",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-home-assistant"],
  "env": {
    "HA_URL": "http://homeassistant.local:8123",
    "HA_TOKEN": "vault:home_assistant_token"
  }
}

Next, set up scheduled routines in the Scheduler. Routines are just scheduled messages — the assistant receives the message, interprets it, and makes the appropriate MCP call.

— Routine 1: sunset lights —
Message:   Turn on the living room and hallway lights.
Schedule:  0 20 * * *   (daily at 20:00 — adjust to local sunset)

— Routine 2: thermostat check —
Message:   Check the thermostat. If the temperature is outside 18–22°C, alert me.
Schedule:  0 * * * *    (every hour)

Conversational Control

With the MCP server connected, you can control devices through natural language in any channel. The assistant translates your request into the appropriate MCP call transparently.

You:       Turn off the living room lights.

ScalyClaw: Done.

→ mcp_call: home-assistant/call_service
    domain: light
    service: turn_off
    entity_id: light.living_room

You:       What's the temperature in the bedroom?

ScalyClaw: The bedroom sensor reads 19.4°C.

→ mcp_call: home-assistant/get_state
    entity_id: sensor.bedroom_temperature

You:       Set the thermostat to 21 degrees.

ScalyClaw: Thermostat set to 21°C.

→ mcp_call: home-assistant/call_service
    domain: climate
    service: set_temperature
    entity_id: climate.main_thermostat
    temperature: 21

Home Automation Skills

• device-status — queries the state of all devices in a given area and formats a readable summary (useful for morning briefings)
• routine-runner — triggers a named Home Assistant scene or script by name, letting you say "run the movie night scene" without knowing the entity ID

Setup Checklist

• Enable the Home Assistant REST or WebSocket API and generate a long-lived access token
• Store the token in the Vault via the dashboard
• Add the Home Assistant MCP server on the MCP page
• Enable proactive engagement and set your preferred alert channel (Telegram or Discord)
• Create scheduled routines in the Scheduler for time-based automations
• Install device-status and routine-runner skills
• Test with a simple "turn on the lights" message before building routines