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

If you already downloaded the installer in Section 4, you can use it directly. (If not, go back to Section 4 and download install_core_pack.py first.)

Have your agent run it

openclaw agent --agent [your-agent-id] "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 ID is the value of AGENT_ID in your .env file.

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. It represents a mode of operation. 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 switch between cassettes depending on what they need to work on that day.

The cassette system is mode-based. One file — ACTIVE_MODE.txt — tells every agent which cassette is currently active. When you switch modes, you update that file. The agents read it at session start and load the right skills automatically.

This means:

• Today: ACTIVE_MODE.txt says youtube → agents load YouTube skills
• Tomorrow: you change it to trade → agents load trading skills
• The agent doesn't change. The mode changes.

And when you switch back to youtube next week, your agents pick up exactly where they left off — the LIVE_LEDGER remembers the progress, and KNOWLEDGE carries the lessons learned. Every mode keeps its own memory independently.

---

Cassette Folder Structure

INFO

~/.openclaw/workspace-[agentid]/ └── cassettes/ ├── ACTIVE_MODE.txt ← One word: the active mode name ├── archive/ ← LIVE_LEDGER and KNOWLEDGE overflow ├── youtube/ │ ├── SKILL_YOUTUBE.md ← Skills for this mode │ ├── WORKFLOW_YOUTUBE.md ← Step-by-step procedures │ ├── LIVE_LEDGER_YOUTUBE.md ← Progress, next actions (updated every session) │ └── KNOWLEDGE_YOUTUBE.md ← Accumulated learning (updated every session) ├── restaurant-ops/ │ ├── SKILL_RESTAURANT.md │ ├── WORKFLOW_RESTAURANT.md │ ├── LIVE_LEDGER_RESTAURANT.md │ └── KNOWLEDGE_RESTAURANT.md └── trade/ ├── SKILL_TRADE.md ├── WORKFLOW_TRADE.md ├── LIVE_LEDGER_TRADE.md └── KNOWLEDGE_TRADE.md

ACTIVE_MODE.txt contains a single word — the name of the active cassette folder. For example:

youtube

At session start, each agent reads ACTIVE_MODE.txt, then loads all four files from that folder: SKILL, WORKFLOW, LIVE_LEDGER, and KNOWLEDGE. LIVE_LEDGER tells them where they left off last session. KNOWLEDGE gives them everything learned so far in this domain.

At session end, the agent updates LIVE_LEDGER (progress, next task) and KNOWLEDGE (new patterns learned). When either file exceeds 800 lines, the RECENT section moves to archive/ — the SUMMARY and PINNED sections always stay at the top.

Scheduled tasks (like a daily health check or a nightly report) run regardless of mode — 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

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 ACTIVE_MODE.txt flag
6. Test that your agent loads the correct mode

Paste the prompt into Claude, ChatGPT, or Gemini. 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).
My agents can switch between cassettes depending on what they 
need to work on.

The cassette system is mode-based. One file — ACTIVE_MODE.txt —
tells every agent which cassette is currently active.

Folder structure:
~/.openclaw/workspace-[agentid]/
  cassettes/
    ACTIVE_MODE.txt              ← active mode name (one word)
    archive/                     ← overflow for LIVE_LEDGER and KNOWLEDGE
    [mode-name]/
      SKILL_[MODENAME].md        ← skills for this mode
      WORKFLOW_[MODENAME].md     ← procedures for this mode
      LIVE_LEDGER_[MODENAME].md  ← progress, next actions (updated every session)
      KNOWLEDGE_[MODENAME].md    ← accumulated learning (updated every session)

At session start, each agent:
1. Reads ACTIVE_MODE.txt
2. Loads SKILL, WORKFLOW, LIVE_LEDGER, and KNOWLEDGE from that folder
3. Resumes from where LIVE_LEDGER says they left off
4. Applies accumulated learning from KNOWLEDGE
5. Operates in that mode for the session

At session end, the agent:
1. Updates LIVE_LEDGER (progress, next task)
2. Updates KNOWLEDGE (new patterns learned)
3. If either file exceeds 800 lines: moves RECENT section to archive/
   SUMMARY and PINNED always stay at the top

Scheduled tasks run regardless of mode — 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 the value in ACTIVE_MODE.txt.
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_[MODENAME].md
Generate the skill file using this structure:

---
# SKILL_[MODENAME].md
Mode: [mode-name]
Version: 1.0
Last Updated: [today's date]
Primary Agent: [agent name]
AI Engine: [engine]

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

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

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

## Operating Rules
1. Read ACTIVE_MODE.txt at session start. If it says [mode-name],
   load this file, WORKFLOW_[MODENAME].md, LIVE_LEDGER_[MODENAME].md,
   and KNOWLEDGE_[MODENAME].md immediately.
2. Resume work from where LIVE_LEDGER says you left off.
3. Apply patterns and lessons from KNOWLEDGE before starting tasks.
4. [Key rule specific to this domain]
5. [Key rule specific to this domain]
6. Report all completed tasks to Discord before ending session.
7. Never act outside this mode's scope without Commander approval.
8. Save all outputs to cassettes/[mode-name]/outputs/

## Session End Rules
At the end of every session, update both memory files:

LIVE_LEDGER_[MODENAME].md:
- SUMMARY: refresh the 3-5 line overview at the top
- CURRENT: update with today's progress and the next task
- RECENT LOG: append this session's activity
- If over 800 lines: move RECENT LOG to archive/

KNOWLEDGE_[MODENAME].md:
- SUMMARY: refresh the overview at the top
- PATTERNS: add any new success or failure patterns discovered today
- RECENT: append today's learnings
- If over 800 lines: move RECENT to archive/

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

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

Show it completely. Ask if anything needs adjustment.

STEP 6 — Generate WORKFLOW_[MODENAME].md
Generate the workflow file using this structure:

---
# WORKFLOW_[MODENAME].md
Mode: [mode-name]
Version: 1.0
Last Updated: [today's date]

## Mode Activation (Every Session Start)
1. Read cassettes/ACTIVE_MODE.txt — confirm it says [mode-name]
2. Load SKILL_[MODENAME].md
3. Read LIVE_LEDGER_[MODENAME].md — resume from last session
4. Read KNOWLEDGE_[MODENAME].md — apply accumulated learning
5. Report to Discord: "📦 Mode: [mode-name] active. Resuming: [current task from LIVE_LEDGER]."

## 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: cassettes/[mode-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)
1. Update LIVE_LEDGER_[MODENAME].md:
   - Refresh SUMMARY (3-5 line overview of current state)
   - Update CURRENT (today's progress + the single next task)
   - Append to RECENT LOG
   - If over 800 lines: move RECENT LOG to archive/
2. Update KNOWLEDGE_[MODENAME].md:
   - Refresh SUMMARY
   - Add new success/failure patterns to PATTERNS
   - Append today's learnings to RECENT
   - If over 800 lines: move RECENT to archive/
3. Send end-of-session report to Discord:
   "✅ [Mode name] session complete.
   Tasks completed: [list]
   Output: cassettes/[mode-name]/outputs/
   Issues: [any errors]
   LIVE_LEDGER updated: [yes]
   KNOWLEDGE updated: [yes]
   Next: [next task from LIVE_LEDGER]"

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

## Scheduled Tasks (Mode-Independent)
These run every session regardless of active mode:
- Session start: confirm identity, read ACTIVE_MODE.txt, load all mode files
- Session end: update LIVE_LEDGER and KNOWLEDGE, post Discord report
---

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 C:\Users\%USERNAME%\.openclaw\workspace-[agentid]\cassettes
  mkdir [mode-name]
  mkdir [mode-name]\outputs

Mac:
  mkdir -p ~/.openclaw/workspace-[agentid]/cassettes/[mode-name]/outputs

Then guide me to write ACTIVE_MODE.txt:
"Open ACTIVE_MODE.txt in VS Code (already created in Section 4).
Type the mode name exactly: [mode-name]
Save."

Then guide me to save these files into the mode folder:
- SKILL_[MODENAME].md
- WORKFLOW_[MODENAME].md

Then guide me to create two initial memory files in the mode folder.

For LIVE_LEDGER_[MODENAME].md, create with this content:
---
# LIVE_LEDGER_[MODENAME].md
Mode: [mode-name]
Created: [today's date]

## SUMMARY
[Agent will write here after first session]

## PINNED
[Critical decisions or rules that must never be forgotten —
 agent and Commander add items here manually]

## CURRENT
Status: Not yet started
Next task: Run first session to initialize this ledger

## RECENT LOG
[Agent appends here after each session]
---

For KNOWLEDGE_[MODENAME].md, create with this content:
---
# KNOWLEDGE_[MODENAME].md
Mode: [mode-name]
Created: [today's date]

## SUMMARY
[Agent will write here after first session]

## PINNED
[Hard-won lessons that must never be forgotten —
 agent and Commander add items here manually]

## PATTERNS
### Success Patterns
[Agent adds here when something works well]

### Failure Patterns
[Agent adds here when something fails — so it never repeats]

## RECENT
[Agent appends learnings after each session]
---

Tell me: "These two files are your agent's memory for this mode.
They start empty and grow automatically as your agent works.
The agent updates them at the end of every session."

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 every file with UTF-8 encoding
- 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 balia-os folder, then run it in the VS Code terminal.
You'll see ✅ for each file created."

STEP 9 — Update current mode in SPEC file
The cassette system rules were already added to SPEC_[AGENTNAME].md
in Section 4. All we need to do now is update the current mode.

Guide me to open SPEC_[AGENTNAME].md and find the
"## Cassette System Rules" section.
Update the line that says "Current mode:" to:
  Current mode: [mode-name]

For the CEO agent's SPEC only, also add this rule under
"## Cassette System Rules":

Mode switching:
- Only the CEO can switch modes
- When Commander says "Switch to [mode] mode":
  1. Write [mode] into cassettes/ACTIVE_MODE.txt
  2. Report to Discord: "✅ Mode switched to: [mode]"
  3. Do not load the new mode yourself — each agent loads it
     at their own next session start

Tell me: "The cassette system was already configured in Section 4.
This update records the first active mode and gives your CEO
agent the authority to switch modes on your command."

STEP 10 — Test the cassette
Guide me to send a test command:

openclaw agent --agent [agentid] "Please do the following:
1. Read cassettes/ACTIVE_MODE.txt and tell me what mode is active.
2. Load SKILL, WORKFLOW, LIVE_LEDGER, and KNOWLEDGE for that mode.
3. Read LIVE_LEDGER — tell me the current status.
4. Read KNOWLEDGE — confirm it is initialized.
5. Confirm you understand your tasks in this mode.
6. Post a readiness report to your Discord channel."

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

FINAL OUTPUT
When confirmed, show this summary:

---
CASSETTE INSTALLED
Mode name: [mode-name]
Primary agent: [agent name]
Files created:
  cassettes/ACTIVE_MODE.txt ✅ (contains: [mode-name])
  cassettes/[mode-name]/SKILL_[MODENAME].md ✅
  cassettes/[mode-name]/WORKFLOW_[MODENAME].md ✅
  cassettes/[mode-name]/LIVE_LEDGER_[MODENAME].md ✅ (initialized)
  cassettes/[mode-name]/KNOWLEDGE_[MODENAME].md ✅ (initialized)
  cassettes/[mode-name]/outputs/ ✅
AI Engine: [engine]
Additional API keys: [added / not needed]
Status: Active — agent confirmed mode loaded
---

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 balia-os 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, WORKFLOW, LIVE_LEDGER, KNOWLEDGE files with correct content
• Creates the outputs/ folder
• Writes the mode name into ACTIVE_MODE.txt

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

---

Switching Modes

To switch modes, tell your CEO agent:

openclaw agent --agent ceo "Switch to [new-mode] mode."

The CEO agent updates ACTIVE_MODE.txt and reports to Discord when done.

Each agent reads ACTIVE_MODE.txt when their own session starts — they automatically load the SKILL, WORKFLOW, LIVE_LEDGER, and KNOWLEDGE for the new mode.

Switching back to a previous mode picks up exactly where you left off — each mode keeps its own LIVE_LEDGER and KNOWLEDGE independently. Your YouTube progress is there when you return to YouTube mode. Your trade analysis is there when you return to trade mode.

You (CEO)
  ↓ "Switch to trade mode"
  CEO agent writes ACTIVE_MODE.txt → "trade"
  CEO agent reports to Discord: "✅ Mode switched to: trade"
      ↓ (next time each agent starts their session)
  Agent A reads ACTIVE_MODE.txt → loads SKILL_TRADE + LIVE_LEDGER_TRADE + KNOWLEDGE_TRADE
  Agent B reads ACTIVE_MODE.txt → loads SKILL_TRADE + LIVE_LEDGER_TRADE + KNOWLEDGE_TRADE
  Agent C reads ACTIVE_MODE.txt → loads SKILL_TRADE + LIVE_LEDGER_TRADE + KNOWLEDGE_TRADE

---

Adding More Cassettes Later

As your business grows, add more cassette folders:

INFO

cassettes/ ├── ACTIVE_MODE.txt ├── youtube/ ├── trade/ ├── restaurant-ops/ └── legal-research/ ← add anytime

Build each new cassette the same way: generate SKILL, WORKFLOW, LIVE_LEDGER, and KNOWLEDGE files via the AI concierge, run the setup script. Tell your CEO agent "Switch to [mode-name] mode" to change modes.

---

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.