# How to Install and Use Larry in OpenClaw - Tool: OpenClaw - Difficulty: Beginner - Time required: 10 minutes - Last updated: March 2026 ## TL;DR To use Larry in OpenClaw, run `clawhub install larry` in your terminal, configure any required credentials in your OpenClaw config, and start issuing task automation and productivity prompts directly from OpenClaw chat. Larry is a utility skill in the ClawHub ecosystem designed to enhance task management and streamline repetitive productivity workflows. ## How Larry Enhances Task Automation in OpenClaw Productivity tools often fragment workflows — you switch between a task manager, a note app, a calendar, and a messaging platform to complete a single work cycle. Larry brings a layer of automation to these patterns by operating as a coordination utility inside OpenClaw. Rather than switching between tools manually, you describe what you want to accomplish in OpenClaw chat and Larry handles the sequencing, reminders, and task tracking behind the scenes. Larry's focus is on repeatable productivity patterns: sequences of tasks that follow a predictable structure but vary in specific details each time. Think of weekly report preparation, standup checklist walkthroughs, project kickoff checklists, or end-of-day review sequences. Larry can learn these patterns, prompt you through the steps at the right time, and record completion status — turning irregular manual workflows into consistent automated routines. In the broader ClawHub ecosystem, Larry is one of two complementary utility skills alongside Sag. While both handle automation, they address different use case profiles within OpenClaw. Larry is oriented toward task and productivity workflows — the kind of work coordination that helps individual contributors stay organized and consistent. Sag addresses more technically specific automation patterns. For teams building comprehensive OpenClaw setups, using both in combination covers a wider automation surface than either alone. ## Before you start - OpenClaw installed and running (see openclaw.ai for installation instructions) - ClawHub CLI available in your terminal (bundled with OpenClaw) - Terminal/command line access to run the clawhub install command - Basic familiarity with OpenClaw chat prompts for task-oriented workflows ## Step-by-step guide ### 1. Install the Larry Skill via ClawHub Open your terminal and run the clawhub install command to add Larry to your OpenClaw instance. ClawHub downloads the larry skill package from the registry, verifies the download, and registers it with your local OpenClaw configuration. Installation takes 10-20 seconds. When complete, the terminal displays a confirmation with the installed version number and lists any configuration keys that need to be set before the skill fully activates. Some versions of Larry may work with zero additional configuration for basic task automation features, while more advanced features like calendar integration or external task system sync may require additional credentials. Verify the install succeeded by running `clawhub list` — larry should appear in the output. Then run `clawhub info larry` to see the full configuration reference and understand which features require additional setup. ``` # Install larry clawhub install larry # Verify installation clawhub list # View full configuration reference clawhub info larry ``` **Expected result:** Terminal shows 'larry@X.X.X installed successfully'. The skill appears in `clawhub list` output and `clawhub info larry` displays available configuration options. ### 2. Review and Apply Configuration Options Larry's configuration lives in your OpenClaw `.env` file or in the skill-specific YAML configuration file at `~/.openclaw/skills/larry.yaml`. Unlike some skills that require a third-party API key to function at all, Larry's core features may be usable immediately after installation with sensible defaults. For basic task sequence automation and productivity prompts, review the output of `clawhub info larry` to understand what settings are available. Common configuration options for utility skills like Larry include default task format preferences, session history retention length, and integration hooks for external tools. If Larry requires any configuration variables (such as credentials for an integrated external service), add them using `clawhub config set VARIABLE_NAME value` and then run `clawhub reload` to apply. If Larry works without additional configuration, you can proceed directly to testing — the next step will confirm the skill is active. The larry.yaml skill configuration file is where you define any persistent automation patterns or default workflow templates that you want Larry to recognize without you describing them from scratch each time. ``` # Check if any config is needed (review the output) clawhub info larry # Set any required config values (replace with actual variable names from info output) clawhub config set LARRY_CONFIG_KEY your_value_here # Create/edit skill config file for persistent settings # ~/.openclaw/skills/larry.yaml larry: session_history: 50 # number of past interactions to retain in context default_format: "checklist" # default output format for task sequences verbose_steps: true # show step explanations during task sequences # Apply changes clawhub reload ``` **Expected result:** `clawhub status` shows larry as 'active'. Configuration values are confirmed by `clawhub config get` commands. ### 3. Test Larry with a Simple Task Sequence Open OpenClaw chat and run a test prompt to confirm Larry is active and responding correctly. Start with a simple task that has a clear sequence of steps — something you would normally do manually in a checklist. This gives you a clean baseline before building more complex automation. Larry activates when OpenClaw routes productivity and task management intent to it. You can invoke it explicitly by name ('Larry, do X') or implicitly through prompts that describe task sequence needs. Explicit invocation is more reliable for first-time testing. A good test prompt is a short checklist walkthrough: ask Larry to prompt you through 3-4 steps of something you do regularly, capture your responses, and summarize the result. This exercises the core task automation loop without requiring any external integrations. If Larry does not respond or OpenClaw routes the prompt elsewhere, try prefixing your prompt with 'Use Larry to...' — this makes the skill routing intent unambiguous. **Expected result:** Larry steps through the project health check questions one at a time in OpenClaw chat, waits for your responses, and produces a formatted status summary at the end. The interaction is conversational and context-aware. ### 4. Define a Reusable Automation Workflow Once basic task sequences work, define a reusable workflow that Larry can run on demand without you re-describing the full sequence each time. This is the productivity multiplier: instead of reconstructing a complex workflow from scratch each morning, you invoke it with a short phrase and Larry executes the full sequence. You can define reusable workflows in two ways: either describe them conversationally to Larry and ask it to remember them for future invocations within the session, or define them as named templates in the larry.yaml skill configuration file for persistence across sessions and OpenClaw restarts. Named templates in the configuration file are more reliable for truly recurring workflows. Each template has a name, a description, and a sequence of steps — you then invoke it from OpenClaw chat by name rather than re-specifying all the steps. RapidDev can help teams define and maintain Larry workflow templates for common team processes — especially useful when standardizing workflows across multiple team members who share an OpenClaw setup. ``` # Define named workflow templates in ~/.openclaw/skills/larry.yaml larry: workflows: weekly-review: description: "End-of-week reflection and planning sequence" steps: - prompt: "Review completed tasks from this week. How many were finished vs planned?" - prompt: "Name 3 wins from this week worth celebrating." - prompt: "What 2 things went less well, and what will you do differently?" - prompt: "Set your top 3 priorities for next week." output_format: "summary" daily-standup: description: "Morning standup checklist" steps: - prompt: "What did you complete yesterday?" - prompt: "What are you working on today?" - prompt: "Any blockers or risks?" output_format: "standup" ``` **Expected result:** Larry executes the named workflow on demand when invoked by name from OpenClaw chat, stepping through each defined prompt and generating a formatted output at the end. ### 5. Combine Larry with Other OpenClaw Skills Larry's value compounds when combined with other ClawHub skills. A workflow that Larry orchestrates can trigger actions in other tools — save a weekly review summary to Supermemory for future reference, send a standup message to a Feishu or Discord channel, or update a data record via ByteRover based on task completion data. Combining skills in OpenClaw works through prompt chaining: you describe a multi-tool workflow in a single OpenClaw prompt, and OpenClaw routes each component to the appropriate skill. Larry handles the interactive task sequencing portion, and other skills handle the output actions. For example, a morning workflow might use Larry to step through your daily standup questions, then automatically format and send the standup summary to your team Feishu channel via feishu-bridge, and save the summary to Supermemory for end-of-week review. This entire sequence runs from one multi-step OpenClaw prompt. **Expected result:** OpenClaw runs the Larry standup sequence interactively, then saves the formatted summary to Supermemory without requiring a separate command. The Supermemory entry is retrievable by date. ## Best practices - Invoke Larry explicitly by name in your prompts until you are comfortable with how OpenClaw routes task-oriented requests — explicit invocation removes ambiguity. - Define frequently used workflow sequences as named templates in larry.yaml rather than re-describing them from scratch each session — this saves time and ensures consistent execution. - Keep workflow step prompts focused on a single question or action each — multi-part step prompts reduce the quality of Larry's summaries and make interactive sessions harder to follow. - Set `session_history` in your larry config to retain enough context for your longest workflows — if Larry loses context mid-session, the workflow summary will miss earlier steps. - Combine Larry with Supermemory to persist workflow outputs across sessions — Larry generates insights in context, Supermemory stores them for future retrieval. - Use `verbose_steps: true` during initial setup to understand exactly what Larry is doing at each workflow step; switch it off once your workflows are tuned and running reliably. - Test each named workflow template at least twice after defining it to ensure the step sequence and output format match your expectations before relying on it for critical work. - Use the Sag skill alongside Larry when you need automation patterns that go beyond task and productivity workflows — the two skills complement each other in the ClawHub ecosystem. ## Use cases ### Daily Standup Checklist Automation Configure Larry to walk you through a daily standup checklist in OpenClaw chat each morning — what you completed yesterday, what you are working on today, and any blockers. Larry captures your responses and can format them as a standup summary ready to share with your team. Prompt example: ``` Larry, run my daily standup checklist. Ask me what I completed yesterday, what I'm working on today, and if I have any blockers. Then format my answers as a standup summary I can paste into Slack. ``` ### Recurring Task Sequence Execution Define a multi-step task sequence that Larry executes on demand — for example, an end-of-sprint review that involves specific checks, documentation updates, and team notifications. Larry steps through the sequence, prompting for input at each step that requires human judgment. Prompt example: ``` Larry, run the end-of-sprint review sequence. Walk me through checking the task completion rate, summarizing what was shipped, flagging any unfinished work to carry over, and drafting a one-paragraph sprint summary for the team channel. ``` ### Productivity Pattern Tracking and Review Ask Larry to review your recent task activity in OpenClaw, identify patterns in what types of tasks get completed versus delayed, and suggest workflow adjustments. Larry uses its session history to surface insights about your productivity patterns. Prompt example: ``` Larry, review the tasks I've run through you this week and give me a summary: how many tasks were completed on time, which categories took the longest, and what one change to my workflow could improve my completion rate next week. ``` ## Troubleshooting ### Larry is installed but does not respond to prompts — OpenClaw routes task prompts to a different skill Cause: OpenClaw may be routing general task prompts to a different installed skill with overlapping intent. The routing depends on how skills declare their capabilities and which skills are installed. Solution: Invoke Larry explicitly by name in your prompt: 'Larry, [your request]' or 'Use the Larry skill to [your request]'. This bypasses ambiguous routing and ensures the larry skill handles the prompt directly. ### `clawhub install larry` fails with '429 Too Many Requests' or hangs without completing Cause: ClawHub's skill registry enforces rate limits during peak periods. This is a ClawHub registry issue unrelated to Larry. Solution: Wait 2-5 minutes and retry the install command. If a partial install is blocking retries, run `clawhub install larry --force` to clear the incomplete state and start fresh. ``` # Clear partial install and retry clawhub install larry --force ``` ### Larry workflow steps do not wait for my responses — it runs all steps and outputs a summary without interactive pauses Cause: Larry may be configured for batch mode rather than interactive mode, or the workflow template is defined with all steps run automatically without waiting for input. Solution: Add explicit 'interactive: true' to your workflow template in larry.yaml, or rephrase your OpenClaw prompt to include 'wait for my response at each step before continuing'. Interactive mode must be signaled either in configuration or in the prompt. ``` # Set interactive mode in workflow config larry: workflows: my-workflow: interactive: true # wait for user response at each step steps: [] ``` ### Larry configuration variables are set but running `clawhub status larry` shows 'needs configuration' Cause: A required configuration variable is missing, or the variable name used in the config does not exactly match what the skill expects (case-sensitive). Solution: Run `clawhub info larry` and compare the required variable names exactly against what you have set. Variable names are case-sensitive — LARRY_KEY and larry_key are treated as different variables. Re-run `clawhub config set` with the correct exact variable name and then `clawhub reload`. ``` # Check all current config values related to larry clawhub config list | grep -i larry # Re-set with correct variable name from clawhub info output clawhub config set CORRECT_VARIABLE_NAME your_value clawhub reload ``` ## Frequently asked questions ### How do I install Larry in OpenClaw? Run `clawhub install larry` in your terminal. Larry may work immediately for basic task automation after installation, or it may require some configuration — run `clawhub info larry` to see what is needed. Once installed and configured, invoke Larry from OpenClaw chat by name: 'Larry, [your request]'. ### What is Larry used for in OpenClaw? Larry is a utility skill for task automation and productivity enhancement. It helps you define and run multi-step task sequences, maintain workflow templates for recurring processes, and step through interactive checklists in OpenClaw chat. Think of it as a workflow coordination layer for personal and team productivity patterns. ### What is the difference between Larry and Sag in OpenClaw? Larry and Sag are both utility skills in the ClawHub ecosystem, but they address different automation profiles. Larry focuses on task management and productivity workflows — checklists, standup sequences, review templates. Sag focuses on more technically specific automation patterns. Both can be installed simultaneously and complement each other. ### How do I configure the Larry skill in OpenClaw? Run `clawhub info larry` to see required and optional configuration. Set any required values with `clawhub config set VARIABLE_NAME value`. For persistent workflow templates, create or edit `~/.openclaw/skills/larry.yaml`. Run `clawhub reload` to apply any configuration changes. ### ClawHub install larry is not working — what should I do? Verify the exact skill name is `larry` (all lowercase). If the install fails with a 429 or network error, wait 2-3 minutes and retry. If a partial install is blocking retries, run `clawhub install larry --force` to clear the incomplete state. Run `clawhub --version` first to confirm ClawHub itself is accessible. ### Can RapidDev help configure Larry workflows for my team? Yes — RapidDev helps teams define and maintain Larry workflow templates for recurring processes like standups, sprint reviews, onboarding checklists, and incident postmortems. If your team needs standardized OpenClaw workflows across multiple users, RapidDev can assist with both the Larry configuration and connecting it to other skills in your workflow. ### Can Larry remember workflow templates between OpenClaw sessions? Yes — define named workflow templates in `~/.openclaw/skills/larry.yaml` and they persist across sessions and OpenClaw restarts. Templates defined only in chat during a session are lost when the session ends. Use the YAML configuration file for any workflow you plan to use more than once. --- Source: https://www.rapidevelopers.com/openclaw-integrations/larry © RapidDev — https://www.rapidevelopers.com/openclaw-integrations/larry