Install the Core Skill Pack

Now that your agents are running, let's give them their first real task. BALIA OS comes with three built-in skills ready to deploy.

Skill	Purpose
lightpanda	Fast web search and scraping
summarize	Auto-summarize long text or web pages
clawsec	Security monitoring and new skill quarantine

In Section 4, you used the same script to install the Security Guardian. This is the second run — it installs the core skill pack (lightpanda / summarize / clawsec). (If you haven't downloaded it yet, go back to Section 4 and download install_core_pack.py first.)

Have your agent run it

Paste this into the VS Code terminal and press Enter to run.

What is a Token?

It is the string after ?token= in the access URL sent to you after purchase.

Example: https://guide.baliaos.com/?token=BALIA-XXXX-XXXX-0001 In this case, the token is BALIA-XXXX-XXXX-0001.

If you can't find the email, please contact support.

openclaw agent --agent security-guardian "Please run the following:
python install_core_pack.py --lang en
(The token will be read automatically from your .env file)
Report to Discord when done."

Your agent will autonomously:

1. Authenticate your token
2. Download the core skill pack (lightpanda / summarize / clawsec)
3. Deploy to ~/.opengoat/skills/
4. Update _SKILL_INDEX.md
5. Report "Core skill pack installed" to Discord

Once you receive the Discord confirmation, continue below.

---

What Skills and Cassettes Are

Your agents are live. They have identities, reporting procedures, and Discord channels. But right now, they don't know what domain they're working in. They don't know whether they're managing a restaurant, running a trading operation, or supporting a legal practice.

Skills are the knowledge files you write and give to your agents. Each skill teaches an agent how to do a specific task — how to manage reservations, how to generate a P&L report, how to draft an SNS post. The more skills you give an agent, the more they can do.

A cassette is a folder of skills, bundled together around a theme. A restaurant operator might have a restaurant-ops cassette. A content creator might have a youtube cassette and a social-media cassette. The same agent can use different cassettes depending on what they need to work on that day.

Every cassette is ON by default. One file — memory/_SKILL_STATUS.md — lists every cassette with its ON/OFF status. There's no "current mode" to switch — all your cassettes are available at the same time, and an agent applies whichever cassette matches the task you give it (its SKILL.md describes what it's for). You only turn a cassette OFF in the rare case you want to pause it — for example, if two cassettes conflict with each other (see "If Two Cassettes Conflict" below).

This means:

• marketing-outreach and ai-meeting-daily can both be ON and run at the same time
• Turning one cassette OFF doesn't affect the others
• The agent config never changes — only the cassette STATUS changes

---

Cassette Folder Structure

$env:USERPROFILE\.opengoat\
├── memory\
│   └── _SKILL_STATUS.md              ← ON/OFF list for every cassette
└── skills\
    ├── youtube\
    │   ├── SKILL.md                  ← What this cassette does, tools, rules
    │   └── WORKFLOW.md                ← Step-by-step procedures
    ├── restaurant-ops\
    │   ├── SKILL.md
    │   └── WORKFLOW.md
    └── trade\
        ├── SKILL.md
        └── WORKFLOW.md

_SKILL_STATUS.md lists every cassette with its STATUS flag. For example:

| Cassette Name    | STATUS | Description                  |
|------------------|--------|-------------------------------|
| youtube          | ON     | YouTube content pipeline      |
| trade            | ON     | Market analysis and reporting |

When you give an agent an instruction, it matches what you're asking against the SKILL.md of every cassette that is ON and applies the one that fits — you can also name the cassette explicitly ("Work in trade mode: ...") to be specific. If a cassette is OFF, the agent skips it entirely, even if the task would otherwise match.

Scheduled tasks (like a daily health check or a nightly report) run regardless of which cassettes are on — they are defined in the agent's AGENTS.md, not in any cassette.

---

Choosing Your AI Engine

Different cassettes work best with different AI models. Set this once when you build the cassette.

Cassette Type	Recommended Engine	Why
Crypto trading / Market analysis	Claude	Logical reasoning, pattern analysis, nuanced judgment
Coding / Technical automation	Claude	Code quality, debugging, multi-step logic
Legal research / Contract review	Claude	Careful reasoning, nuanced language
Finance / Accounting / Reporting	Claude	Structured analysis, precise calculation
Google Sheets / Docs / NotebookLM / Drive	Gemini	Native Google service integration
YouTube / Video content	Gemini	Analyzes video directly; integrates with YouTube Studio
Gmail / Calendar automation	Gemini	Deep Google Workspace integration
Sales / Outreach / Copywriting	GPT-4o	Natural conversation, email generation
Multilingual communication	GPT-4o or Gemini	Strong multilingual performance
E-commerce / Product research	Claude or GPT-4o	Research depth, structured output

If Claude works for your use case, you're already set — it was configured in Section 3.

For Gemini or GPT-4o, you'll add an API key to your .env file. Instructions are in Step 7 of the AI concierge below.

---

Skill Ideas by Industry

Not sure what skills to build? Here are starting points by use case.

Restaurant / Food & Beverage

• Reservation management and daily scheduling
• Supplier order tracking and inventory alerts
• Customer SNS posting (daily specials, events)
• Review monitoring and response drafting
• Weekly revenue summary

E-Commerce / Physical Products

• Product listing generation
• Competitor price monitoring
• Order status summarization
• Customer inquiry response drafting
• Monthly sales reporting

Content Creator / YouTuber

• Title and thumbnail idea generation
• Script outline drafting
• Upload schedule management
• Performance metrics summarization
• Community comment response drafting

Freelancer / Consultant

• Client communication drafting
• Project status reporting
• Invoice tracking and follow-up
• Contract clause review (flag unusual terms)
• Time log summarization

Small Business / General

• Daily operations summary
• Staff communication drafting
• Legal question screening (flag items requiring a lawyer)
• Financial summary from receipts and records
• Vendor communication management

Your own industry is not on this list? That's fine — the AI concierge in this section will help you define your own skills from scratch based on what you want your team to actually do.

---

How This Section Works

Recommended: Use the AI concierge prompt below — it generates all your cassette files AND produces a Python setup script that creates everything automatically. After the AI conversation, go to Step 2 — Run the Setup Script and run it. No manual file creation needed.

If the setup script fails: The AI concierge also shows you each file's full content. You can create the files manually in VS Code as a fallback.

Use the AI concierge prompt below to:

1. Define what your agents should do every day
2. Decide which cassette name and mode to start with
3. Choose the right AI engine
4. Generate your SKILL and WORKFLOW files
5. Set up the _SKILL_STATUS.md flag
6. Test that your agent loads the correct mode

Paste the prompt into your chat AI. Attach your Team Design Document from Section 2.

---

▶ Paste this into your AI to get started

Attach your Team Design Document before sending.

You are helping me build Skills and a Cassette for BALIA OS —
a multi-agent AI operating system.

I have attached my Team Design Document. Read it before we begin
so you know my agent names, roles, and workspace structure.

CONCEPT TO UNDERSTAND BEFORE WE START:

Skills are knowledge files I write and give to my agents.
Each skill teaches an agent how to do a specific task.

A Cassette is a folder of skills, bundled around a theme (a mode).
All cassettes are ON by default and can run at the same time —
my agents apply whichever cassette fits the task I give them.

One file — memory/_SKILL_STATUS.md — lists every cassette with an
ON/OFF status. It's the single source of truth for which cassettes
are available. It is not "current mode" — multiple rows can be ON
at once.

Folder structure:
$env:USERPROFILE/.opengoat/
  memory/
    _SKILL_STATUS.md            ← ON/OFF list, one row per cassette
  skills/
    [cassette-name]/
      SKILL.md                  ← what this cassette does, tools, rules
      WORKFLOW.md                ← step-by-step procedures for this cassette

When I give an agent an instruction:
1. The agent checks which cassettes are ON in memory/_SKILL_STATUS.md
2. It matches my instruction against each ON cassette's SKILL.md
   (or I can name the cassette explicitly, e.g. "Work in trade mode: ...")
3. It applies the matching cassette's SKILL.md and WORKFLOW.md

Scheduled tasks run regardless of which cassettes are ON — they are in AGENTS.md.

Guide me step by step. Ask one question at a time.
Wait for my answer before moving on.

STEP 1 — What I want my team to do
Ask me: "Describe what you want your AI team doing for you every day.
Don't think about how — just describe the output you want
and the work you want done."

Help me turn my answer into a list of at least 5 specific,
recurring tasks. Ask follow-up questions until we have
concrete tasks with a clear schedule (daily, weekly, on-demand).

STEP 2 — Map tasks to agents
Read my Team Design Document.
Match each task to the most appropriate agent based on their role.
Show me the mapping: "Task → Agent"
Ask: "Does this feel right? Anything you'd move?"

STEP 3 — Name the cassette (mode)
Based on the tasks, suggest a cassette name — the mode name
(short, lowercase, hyphens: e.g. restaurant-ops, youtube, trade).
This becomes the folder name and a new row in memory/_SKILL_STATUS.md.
Ask me to confirm or suggest a different name.

STEP 4 — Choose the AI engine
For each agent with tasks mapped, recommend the best engine:

- Claude: logic, analysis, coding, legal, finance, crypto
- Gemini: Google services (Sheets, Docs, Drive, Gmail, Calendar,
  YouTube Studio, NotebookLM) — anything in the Google ecosystem
- GPT-4o: sales emails, outreach, copywriting, natural conversation

Explain your reasoning in one sentence per agent.
If all tasks work well with Claude, confirm no extra API keys needed.
If Gemini or GPT-4o needed, note it — we handle the key in Step 7.

Ask me to confirm before moving on.

STEP 5 — Generate SKILL.md
Generate the skill file using this structure:

---
# SKILL.md — [cassette-name]
Version: 1.0
Last Updated: [today's date]
Primary Agent: [agent name]
AI Engine: [engine]

## What This Cassette Does
[2-3 sentences: what domain this covers, what it produces]

## When To Use This Cassette
[1-2 sentences describing the kinds of instructions that should trigger
this cassette — this is what the agent matches your requests against]

## Skills in This Cassette
[Bullet list of specific skills — what the agent knows how to do]

## Tools Available
[List tools usable in this cassette: web search, file read/write,
Discord reporting, API calls, Google services, etc.]

## Operating Rules
1. Before running, confirm this cassette's row in memory/_SKILL_STATUS.md
   is set to ON. If OFF, skip entirely — no Discord report needed.
2. [Key rule specific to this domain]
3. [Key rule specific to this domain]
4. Report all completed tasks to Discord before ending session.
5. Never act outside this cassette's scope without Commander approval.
6. Save all outputs to skills/[cassette-name]/outputs/

## What This Cassette Does NOT Handle
[Specific boundaries — what's out of scope for this cassette]

## Output Format
[What the agent produces: reports, files, Discord messages, etc.]
---

Show it completely. Ask if anything needs adjustment.

STEP 6 — Generate WORKFLOW.md
Generate the workflow file using this structure:

---
# WORKFLOW.md — [cassette-name]
Version: 1.0
Last Updated: [today's date]

## Before Starting
1. Confirm this cassette's row in memory/_SKILL_STATUS.md is ON
2. Load SKILL.md from this same folder

## Task Procedures

### [Task 1 Name] — [Schedule]
Trigger: [What starts this task]
Steps:
1. [Specific action]
2. [Specific action]
3. [Specific action]
Output: [What gets produced]
Save to: skills/[cassette-name]/outputs/
On error: [What to do if something fails]

### [Task 2 Name] — [Schedule]
[Same structure]

[Continue for all tasks]

## Session End (Every Session — Required)
Send end-of-session report to Discord:
"✅ [cassette-name] session complete.
Tasks completed: [list]
Output: skills/[cassette-name]/outputs/
Issues: [any errors]"

## Error Handling
If any step fails:
1. Note the exact error
2. Continue with remaining tasks if possible
3. Include all errors in end-of-session Discord report
4. Do not retry destructive operations without Commander approval

## Scheduled Tasks
These run on their own schedule regardless of other cassettes —
they are independent of whether other cassettes are ON or OFF.
---

Show it completely. Ask if anything needs adjustment.

STEP 7 — API key setup (if needed)
Only if Gemini or GPT-4o was recommended in Step 4:

FOR GEMINI:
"Gemini works best for Google service integration.
To get your API key:"
1. Go to https://console.cloud.google.com/
2. Sign in with your Google account
3. If prompted, you may be eligible for $300 in free credits —
   click "Try for free" if offered
4. In the top search bar, type "Gemini API" and select it
5. Click "Enable" if not already enabled
6. Go to "Credentials" in the left menu → "Create Credentials"
   → "API key"
7. Copy the key
8. Add to .env file:
   GOOGLE_API_KEY=your-key-here
Confirm: "Gemini API key added."

FOR GPT-4o (OpenAI):
1. Go to platform.openai.com
2. Sign in or create account
3. Click your profile → "API keys" → "Create new secret key"
4. Name it "balia-os"
5. Copy the key (starts with sk-)
6. Add to .env file:
   OPENAI_API_KEY=your-key-here
Confirm: "OpenAI API key added."

If Claude only: skip this step entirely.

STEP 8 — Create the cassette folder structure
Guide me to create the folders in VS Code terminal:

Windows:
  cd $env:USERPROFILE\.opengoat\skills
  mkdir [mode-name]
  mkdir [mode-name]\outputs

Mac:
  mkdir -p ~/.opengoat/skills/[mode-name]/outputs

Then guide me to save these files into the cassette folder:
- SKILL.md
- WORKFLOW.md

Then guide me to add this cassette to memory/_SKILL_STATUS.md:
"Open memory/_SKILL_STATUS.md in VS Code. If the file doesn't exist yet,
create it with this header:

# SKILL CASSETTE STATUS
# ON/OFF is managed in this file only.

| Cassette Name | STATUS | Description |
|---|---|---|

Add a new row: | [mode-name] | ON | [one-line description] |
Save."

After all files are defined, generate a complete Python setup script
that creates everything automatically. The script must:
- Work on both Windows and Mac (use os.path.expanduser for ~)
- Create all folders with os.makedirs(exist_ok=True)
- Write SKILL.md and WORKFLOW.md with UTF-8 encoding
- Add (or update) this cassette's row in memory/_SKILL_STATUS.md,
  creating the file with the header above if it doesn't exist yet
- Print ✅ [filename] for each file created
- Print "Setup complete." at the end

The script contains all file paths and content already filled in —
the user just runs it in the VS Code terminal with:
  python setup_cassette.py

Tell me: "Copy this script, save it as setup_cassette.py
in your .opengoat folder, then run it in the VS Code terminal.
You'll see ✅ for each file created."

STEP 9 — Test the cassette
Guide me to send a test command, naming the cassette explicitly:

openclaw agent --agent ceo "Work in [mode-name] mode: please do the following:
1. Confirm memory/_SKILL_STATUS.md shows [mode-name] as ON.
2. Load this cassette's SKILL.md and WORKFLOW.md.
3. Confirm you understand your tasks in this cassette.
4. Post a readiness report to your Discord channel."

Ask me: "What did the agent respond?
Did you see a readiness report in Discord?"
If yes: cassette installation confirmed.
If no: help me troubleshoot.

FINAL OUTPUT
When confirmed, show this summary:

---
CASSETTE INSTALLED
Cassette name: [mode-name]
Primary agent: [agent name]
Files created:
  memory/_SKILL_STATUS.md ✅ (row added: [mode-name] — ON)
  skills/[mode-name]/SKILL.md ✅
  skills/[mode-name]/WORKFLOW.md ✅
  skills/[mode-name]/outputs/ ✅
AI Engine: [engine]
Additional API keys: [added / not needed]
Status: ON — agent confirmed readiness
---

Ready for Section 7.

Start now. Ask me the first question.

---

Step 2 — Run the Setup Script

When the AI concierge finishes generating your cassette files, it will also generate a Python setup script with all file paths and content already filled in.

What to do:

1. Copy the Python script the AI generates
2. Open VS Code terminal (Ctrl+`` on Windows / Cmd+`` on Mac)
3. Create a new file called setup_cassette.py in your .opengoat folder
4. Paste the script and save
5. Run it:

   python setup_cassette.py

You'll see a ✅ for each file created. That's it — no manual file creation, no path confusion.

What the script does automatically:

• Creates all folder structure
• Writes SKILL.md and WORKFLOW.md with correct content
• Creates the outputs/ folder
• Adds this cassette's row to memory/_SKILL_STATUS.md (STATUS: ON)

If you see any ❌ in the output, copy the error and ask your AI concierge to fix it.

---

Using a Cassette

All cassettes are ON by default — there's no "switching" step. Just tell any agent which cassette to use at the start of your instruction:

openclaw agent --agent ceo "Work in trade mode: give me today's summary."

The agent matches "trade mode" against the ON cassettes in memory/_SKILL_STATUS.md, loads that cassette's SKILL.md and WORKFLOW.md, and applies them to your request. You can also describe the task without naming the cassette — the agent matches it against each ON cassette's SKILL.md automatically.

Pausing a cassette: Open memory/_SKILL_STATUS.md and set that cassette's STATUS to OFF. The agent will skip it until you turn it back ON.

---

Adding More Cassettes Later

As your business grows, add more cassette folders:

skills/
├── youtube/
├── trade/
├── restaurant-ops/
└── legal-research/      ← add anytime

Build each new cassette the same way: generate SKILL.md and WORKFLOW.md via the AI concierge, run the setup script. It's added to memory/_SKILL_STATUS.md as ON automatically — no switching needed, just tell an agent to use it.

---

The BALIA Skill Market — Coming Q4 2026

Once the market opens, two things become available:

Buy cassettes — BALIA-developed cassettes (Crypto Trade, YouTube, E-Commerce, Polymarket BOT) and community-built cassettes, reviewed and approved. Install them into your cassette folder like any other mode.

Sell cassettes — If you build a cassette that works, submit it. Every submission goes through a security audit and effectiveness review. Once approved, it lists on the market and earns you revenue every time someone installs it.

Details at @BALIA_OS on X when the market opens.

---

Skill Cassette System — ON/OFF Control

Your cassettes are managed by a single file: memory/_SKILL_STATUS.md. New cassettes are added as ON by default.

| Cassette Name       | STATUS | Description                        |
|---------------------|--------|------------------------------------|
| marketing-outreach  | ON     | SNS / email / YouTube outreach     |
| ai-meeting-sales    | ON     | Sales team AI meeting (Leo)        |
| ai-meeting-daily    | ON     | Daily operations meeting           |
| research-market     | ON     | Market research automation         |

To pause a cassette: Change ON to OFF in this file. That's it.

When a cassette is ON:

• Any agent whose task matches it loads the cassette
• Executes the task
• Reports to Discord: "✅ [cassette-name] executed successfully."

When a cassette is OFF:

• The agent skips it, even if the task would otherwise match
• Still reports to Discord: "⏭️ [cassette-name] skipped — STATUS: OFF"

Every execution is reported, whether it ran or not. You always know what happened.

---

If Two Cassettes Conflict

Because every cassette is ON by default, it's possible for two to overlap — for example, two cassettes that both post to the same Discord channel, or both try to use the same agent for conflicting tasks at the same time.

There is currently no automatic conflict detection. If you notice two cassettes stepping on each other, open memory/_SKILL_STATUS.md and set one of them to OFF yourself. This resolves the conflict immediately — the agent skips any cassette marked OFF.

Automatic conflict detection by Security Guardian, with a suggested resolution, is planned for a future update.

---

Scheduling Cassettes — Timed Execution

Some cassettes are designed to run at a fixed time — daily meetings, morning reports, weekly summaries. Register these with your OS scheduler.

The scheduler triggers the cassette. The agent checks _SKILL_STATUS.md. If ON → execute + Discord report. If OFF → skip + Discord report.

⚠️ Two Rules for Scheduled Cassettes

• Always name the cassette/mode in the registration command itself — the scheduler has no other way to know which cassette to run, so the trigger action must spell it out (see the [cassette-name] in the examples below).
• Don't register two scheduled cassettes for the same time slot. Running two at once can make them compete for the same agent or the same Discord channel. Stagger them by at least a few minutes.

---

Windows — Task Scheduler

1. Open Task Scheduler → Create Basic Task
2. Name: BALIA_[CassetteName]
3. Trigger: Daily → set your time (e.g. 21:00)
4. Action: Start a program
   • Program: openclaw
   • Arguments: agent --agent [agentid] "Work in [cassette-name] mode: run today's scheduled task."
   • Start in: C:\Users\%USERNAME%\.opengoat
5. Finish

To pause a scheduled cassette without touching the scheduler: → Set STATUS to OFF in _SKILL_STATUS.md. The scheduler still fires, the agent checks STATUS, skips, and reports. No scheduler changes needed.

---

Mac — launchd

Create ~/Library/LaunchAgents/com.balia.[cassette-name].plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>com.balia.[cassette-name]</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/local/bin/openclaw</string>
    <string>agent</string>
    <string>--agent</string>
    <string>[agentid]</string>
    <string>Work in [cassette-name] mode: run today's scheduled task.</string>
  </array>
  <key>StartCalendarInterval</key>
  <dict>
    <key>Hour</key>
    <integer>21</integer>
    <key>Minute</key>
    <integer>0</integer>
  </dict>
</dict>
</plist>

Load it:

launchctl load ~/Library/LaunchAgents/com.balia.[cassette-name].plist

To pause: set STATUS to OFF in _SKILL_STATUS.md. Same behavior as Windows.