Agent skill

Scaled Swarm Predict

by bolivian-peru in bolivian-peru/os-moda

Large-scale social simulation with 50-200 demographically diverse AI personas debating on a simulated Twitter/Reddit board to predict outcomes

Apache-2.0Auto-check passed

Install Scaled Swarm Predict

skills CLI
$ npx skills add bolivian-peru/os-moda --skill scaled-swarm-predict -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install bolivian-peru/os-moda scaled-swarm-predict --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/bolivian-peru/os-moda.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/scaled-swarm-predict .claude/skills/scaled-swarm-predict && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
scaled-swarm-predict
GitHub stars
119
Token cost
~4.2k tokens
SKILL.md length
894 words
Files
1
Skills in repo
17
Repo updated
First seen
Licence
Apache-2.0

At a glance

Large-scale social simulation with 50-200 demographically diverse AI personas debating on a simulated Twitter/Reddit board to predict outcomes

  • Works in 5 steps: Define the Simulation → Generate Population → Run Simulation Rounds → …
  • SKILL.md covers When to Use, Phase 1: Define the Simulation, Phase 2: Generate Population and Phase 3: Run Simulation Rounds, plus 4 more sections
  • Calls sqlite3 and make

What it does

Scaled Swarm Predict is an agent skill from bolivian-peru/os-moda. Large-scale social simulation with 50-200 demographically diverse AI personas debating on a simulated Twitter/Reddit board to predict outcomes

Its SKILL.md is about 4.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It works with X (Twitter) and Reddit. The repository describes itself as: An operating system built for AI agents — talk to your NixOS server instead of SSH-ing in. Typed, audited tool access with atomic rollback on every change. Research-grade; run it… The licence is Apache-2.0.

Example prompts

  • “/scaled-swarm-predict”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Define the Simulation
  2. Generate Population
  3. Run Simulation Rounds
  4. Analyze Results
  5. Act on Prediction (Optional)

What it can do on your machine

Read from SKILL.md and the folder at commit b8e418f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • sqlite3
    • make

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Scaled Swarm Predict loads about 4.2k tokens when it runs. Until then it costs about 41 tokens; SKILL.md has 894 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~41
When it runs · the whole SKILL.md, loaded when a task matches
~4.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from bolivian-peru/os-moda at commit b8e418f, republished under its Apache-2.0 licence (© bolivian-peru). 894 words, ~4,190 tokens.

Download SKILL.mdSave it as .claude/skills/scaled-swarm-predict/SKILL.md (or your agent's skills folder).
name
scaled-swarm-predict
description
Large-scale social simulation with 50-200 demographically diverse AI personas debating on a simulated Twitter/Reddit board to predict outcomes
activation
manual
tools
system_health, system_query, shell_exec, file_read, file_write, teach_knowledge_create, teach_observe_action, safe_switch_begin, safe_switch_status…

Scaled Swarm Predict

Large-scale social simulation engine. Generates 50-200 demographically diverse AI personas, runs them through a simulated Twitter or Reddit board debating a topic, then analyzes emergent consensus, fault lines, and predictions.

What this is: A structured simulation where you generate a population of diverse personas matching real-world demographics, run 4-6 rounds of simulated social media discussion in a local SQLite database, then analyze position shifts and emergent consensus to make predictions.

What this is NOT: This is not MiroFish/OASIS (which runs independent agent processes). All personas are generated and role-played by a single model. The value comes from forcing diverse demographic perspectives through structured rounds of interaction — not from emergent multi-agent behavior. Think of it as a sophisticated polling simulation, not swarm intelligence.

Cost per run: ~$5-15 with Claude Sonnet (100 agents × 5 rounds = 500 generations). ~$25-60 with Opus. Each round is one large prompt, not 100 separate API calls.

When to Use

  • Predict public reaction: "How will Twitter react to this product launch?"
  • Election/poll modeling: "What does a demographically representative sample think about X policy?"
  • Content testing: "Will this announcement go viral or get ratio'd?"
  • Market sentiment: "How will crypto twitter react to this protocol change?"
  • Risk assessment: "What will the Reddit comments look like when we announce this pricing change?"
  • Brainstorming at scale: "What arguments exist for/against X across different demographics?"

Phase 1: Define the Simulation

1.1 — Get the Topic

Ask the user for:

  1. Topic/scenario — What are we simulating discussion about?
  2. Platform — Twitter (short-form, viral dynamics) or Reddit (long-form, threaded)
  3. Population size — 50 (fast, cheap), 100 (balanced), 200 (thorough)
  4. Seed data — Any documents, articles, data to ground the simulation

If seed data is provided, read it with file_read() and summarize key facts that personas will reference.

1.2 — Create the Board Database

Use shell_exec() to create a SQLite database for the simulation:

bash
sqlite3 /var/lib/osmoda/swarm/sim_$(date +%s).db "
CREATE TABLE personas (
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL,
  age INTEGER,
  gender TEXT,
  location TEXT,
  occupation TEXT,
  political_lean TEXT,
  income_bracket TEXT,
  education TEXT,
  interests TEXT,
  personality TEXT,
  initial_position TEXT,
  bio TEXT
);

CREATE TABLE posts (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  round INTEGER NOT NULL,
  persona_id INTEGER NOT NULL,
  reply_to INTEGER,
  content TEXT NOT NULL,
  position TEXT,
  sentiment REAL,
  likes INTEGER DEFAULT 0,
  retweets INTEGER DEFAULT 0,
  FOREIGN KEY (persona_id) REFERENCES personas(id),
  FOREIGN KEY (reply_to) REFERENCES posts(id)
);

CREATE TABLE position_shifts (
  persona_id INTEGER NOT NULL,
  round INTEGER NOT NULL,
  position_before TEXT,
  position_after TEXT,
  reason TEXT,
  PRIMARY KEY (persona_id, round),
  FOREIGN KEY (persona_id) REFERENCES personas(id)
);

CREATE TABLE analysis (
  round INTEGER PRIMARY KEY,
  summary TEXT,
  top_arguments_for TEXT,
  top_arguments_against TEXT,
  consensus_pct REAL,
  viral_posts TEXT
);
"

Store the database path for all subsequent phases.

Phase 2: Generate Population

2.1 — Define Demographics

Match the population to the scenario. For US topics, use approximate census distributions:

Age:        18-24 (15%), 25-34 (20%), 35-44 (18%), 45-54 (16%), 55-64 (15%), 65+ (16%)
Gender:     Male (49%), Female (50%), Non-binary (1%)
Education:  High school (27%), Some college (20%), Bachelor's (22%), Graduate (13%), Trade/other (18%)
Political:  Liberal (25%), Moderate-left (15%), Center (20%), Moderate-right (15%), Conservative (25%)
Income:     <$30k (20%), $30-60k (25%), $60-100k (25%), $100-150k (18%), $150k+ (12%)

For tech/crypto topics, skew younger, more male, higher education. For local issues, adjust by region. Always tell the user what distribution you're using and why.

2.2 — Generate Personas in Batches

Generate personas in batches of 20-25 to stay within context limits. Each batch prompt:

Generate [N] realistic social media personas for a [Twitter/Reddit] simulation about "[topic]".

Demographics for this batch: [specify age/gender/political/income distribution for this batch]

For each persona, output JSON:
{
  "name": "realistic full name matching demographics",
  "age": N,
  "gender": "...",
  "location": "city, state",
  "occupation": "specific job title",
  "political_lean": "liberal|moderate-left|center|moderate-right|conservative",
  "income_bracket": "$X-Y",
  "education": "specific degree or level",
  "interests": "3-5 specific interests",
  "personality": "one sentence: how they argue online (aggressive, thoughtful, sarcastic, lurker-who-snaps, etc.)",
  "initial_position": "support|oppose|undecided|unaware",
  "bio": "their Twitter/Reddit bio, 1-2 sentences, authentic voice"
}

Make them feel REAL — not stereotypes. A conservative plumber can care about climate.
A liberal professor can oppose regulation. Surprise me with 20% of them.

Insert each batch into the personas table via shell_exec() with sqlite3.

2.3 — Validate Distribution

After all batches, verify the demographics match targets:

bash
sqlite3 $DB_PATH "
SELECT political_lean, COUNT(*), ROUND(COUNT(*)*100.0/(SELECT COUNT(*) FROM personas),1) as pct
FROM personas GROUP BY political_lean ORDER BY pct DESC;
"

Report the actual distribution to the user. If any category is off by >5%, generate corrective personas.

Phase 3: Run Simulation Rounds

Run 4-6 rounds. Each round is ONE prompt that generates all persona responses for that round.

Round 1 — First Reactions (all personas post)
You are simulating a [Twitter/Reddit] board. [N] users are reacting to this:

"[TOPIC/ANNOUNCEMENT — paste seed data summary here]"

Here are the users (JSON array of all personas).

Generate a [Twitter post (max 280 chars) / Reddit comment (2-4 sentences)] for EACH persona.
Stay in character — match their age, education, politics, personality, and online voice.

For each persona output:
- persona_id: [N]
- content: "[their post]"
- position: "support|oppose|mixed|joke|question"
- sentiment: [-1.0 to 1.0]

Some personas should:
- Post memes or jokes (15%)
- Ask genuine questions (10%)
- Share personal anecdotes (10%)
- Make strong arguments for/against (40%)
- Just react emotionally (15%)
- Stay silent this round (10% — not everyone posts immediately)

Do NOT make everyone articulate. Some posts should be typos, slang, ALL CAPS, one-word reactions.

Parse the output and INSERT into the posts table.

Round 2 — Replies and Reactions
Round 1 posts are below. Now generate Round 2: replies and reactions.

[Paste Round 1 posts — all of them, with persona names and IDs]

Rules for Round 2:
- Each persona reads 5-10 random posts from Round 1
- They reply to 1-3 posts (set reply_to = that post's ID)
- They may also make a new top-level post
- 20% of personas shift position based on arguments they read
- Record any position shift in their response

For position shifts, also output:
- position_before
- position_after
- reason: "one sentence — what convinced them"

Viral dynamics: The top 3 posts from Round 1 (by argument strength) get more replies.
Controversial posts get more replies than consensus posts.

Parse and INSERT posts + position_shifts.

Round 3 — Debate Heats Up
Rounds 1-2 are below. Generate Round 3: the debate intensifies.

[Paste all posts from rounds 1-2 with context]

Round 3 dynamics:
- Tribal clusters form: personas start agreeing with similar demographics
- Counter-arguments appear: personas cite specific earlier posts to rebut
- Information spreads: facts from seed data appear in arguments (with varying accuracy)
- 10% of personas get heated (personal attacks, sarcasm, ratio attempts)
- 15% more position shifts
- Lurkers from Round 1 now engage (the silent 10%)
- 5% of personas disengage ("this is pointless" / "touch grass")
Round 4 — Consolidation
Full thread so far (Rounds 1-3). Generate Round 4: positions solidify.

Round 4 dynamics:
- Most personas have firm positions now
- Summary posts appear ("the real issue is...")
- Final position shifts (5-10% max — late deciders)
- Thread fatigue: 30% of personas stop posting
- Quality arguments bubble up, low-effort posts sink
- Some personas change the topic or go meta ("why are we even arguing about this")
Optional Round 5 — Next Day Follow-up
24 hours later. The thread has cooled. Generate Round 5.

Round 5 dynamics:
- Only 30-40% of personas return
- Tone shifts: more reflective, less combative
- New information may have emerged (you can introduce one new fact)
- "I thought about it and..." posts (final position shifts)
- Someone writes a long "thread" summarizing both sides
Optional Round 6 — External Event

Only use if the simulation benefits from a disruption:

BREAKING: [New information related to the topic]

How do personas react? Generate Round 6.
- 60% of personas react to the new info
- Position shifts may be dramatic
- Previous arguments get re-evaluated

Phase 4: Analyze Results

4.1 — Quantitative Analysis

Run these queries against the database:

bash
# Final position distribution
sqlite3 $DB_PATH "
SELECT position, COUNT(*) as count,
  ROUND(COUNT(*)*100.0/(SELECT COUNT(*) FROM posts WHERE round=(SELECT MAX(round) FROM posts)),1) as pct
FROM posts WHERE round = (SELECT MAX(round) FROM posts)
GROUP BY position ORDER BY count DESC;
"

# Position shifts over time
sqlite3 $DB_PATH "
SELECT round, position_after, COUNT(*) as shifts
FROM position_shifts
GROUP BY round, position_after
ORDER BY round, shifts DESC;
"

# Most influential posts (most replies received)
sqlite3 $DB_PATH "
SELECT p.id, per.name, p.content, COUNT(r.id) as reply_count
FROM posts p
JOIN personas per ON p.persona_id = per.id
LEFT JOIN posts r ON r.reply_to = p.id
GROUP BY p.id
ORDER BY reply_count DESC
LIMIT 10;
"

# Sentiment by demographic
sqlite3 $DB_PATH "
SELECT per.political_lean, ROUND(AVG(p.sentiment),2) as avg_sentiment
FROM posts p JOIN personas per ON p.persona_id = per.id
WHERE p.round = (SELECT MAX(round) FROM posts)
GROUP BY per.political_lean;
"

# Age group sentiment
sqlite3 $DB_PATH "
SELECT
  CASE WHEN per.age < 25 THEN '18-24'
       WHEN per.age < 35 THEN '25-34'
       WHEN per.age < 45 THEN '35-44'
       WHEN per.age < 55 THEN '45-54'
       WHEN per.age < 65 THEN '55-64'
       ELSE '65+' END as age_group,
  ROUND(AVG(p.sentiment),2) as avg_sentiment,
  COUNT(DISTINCT per.id) as persona_count
FROM posts p JOIN personas per ON p.persona_id = per.id
WHERE p.round = (SELECT MAX(round) FROM posts)
GROUP BY age_group ORDER BY age_group;
"
4.2 — Qualitative Analysis

After running the queries, analyze the full simulation transcript:

Read the full simulation (all rounds, all posts, all position shifts).

Produce this analysis:

1. PREDICTION: What does this simulated population predict/prefer? (1 sentence)
2. CONFIDENCE: How strong is the consensus? (percentage + explanation)
3. FAULT LINES: Where does the population split? (demographics, not just opinion)
4. VIRAL ARGUMENTS: The 3 arguments that changed the most minds (quote them)
5. SURPRISING FINDINGS: What positions appeared that you didn't expect?
6. DEMOGRAPHIC BREAKDOWN: Support/oppose by age, gender, political lean, income
7. SIMULATION HEALTH: Did the personas feel real? Were any rounds shallow?
4.3 — Produce Report

Write the final report to a file:

bash
file_write({
  path: "/var/lib/osmoda/swarm/report_[timestamp].md",
  content: "[full report markdown]"
})

Report format:

markdown
# Scaled Swarm Prediction Report

## Topic
[What was simulated]

## Population
- Size: [N] personas
- Platform: [Twitter/Reddit]
- Rounds: [N]
- Demographic match: [% accuracy to target distribution]

## Prediction
[One clear sentence: what the simulated population predicts/prefers]

## Confidence: [X%]
[Why this confidence level — based on consensus strength, not gut feeling]

## Position Distribution (Final Round)
| Position | Count | % |
|----------|-------|---|
| Support  | N     | X |
| Oppose   | N     | X |
| Mixed    | N     | X |
| Other    | N     | X |

## Demographic Breakdown
[Table: position by age group, political lean, gender, income]

## Key Fault Lines
1. [Demographic split #1 — e.g., "Under-35s support 3:1, over-55s oppose 2:1"]
2. [Demographic split #2]

## Most Influential Arguments
1. "[Quote]" — by [persona name/type], shifted [N] positions
2. "[Quote]"
3. "[Quote]"

## Surprising Findings
- [Thing that broke expectations]

## Position Shifts Over Time
| Round | Support→Oppose | Oppose→Support | Newly Engaged |
|-------|---------------|----------------|---------------|
| 1     | -             | -              | N             |
| 2     | N             | N              | N             |
| ...   |               |                |               |

## Simulation Health
- Persona authenticity: [HIGH/MED/LOW — did they feel real?]
- Debate quality: [Did arguments evolve or repeat?]
- Known bias: [Single model role-playing all personas — positions may cluster]

## Raw Data
Database: [path to SQLite file]
4.4 — Store for Learning
teach_knowledge_create({
  title: "Swarm prediction: [topic]",
  category: "prediction",
  content: "[report summary + prediction + confidence]",
  tags: ["scaled-swarm-predict", "[topic-tag]", "[platform]"]
})
Show full SKILL.md (358 more words)Show less

Phase 5: Act on Prediction (Optional)

If the prediction is actionable and the user approves:

safe_switch_begin({
  plan: "Action based on swarm prediction: [what]",
  ttl_secs: 1800,
  health_checks: [from prediction context]
})

Execute the action, monitor, commit or rollback based on results.

After the action completes, update the knowledge entry with the actual outcome vs prediction. This is the most valuable data — where the simulation was right and where it was wrong.

Limitations (Be Honest)

  1. Single model bias: All 200 personas are generated by one model. The model has its own biases that leak into every persona. Conservative personas written by Claude may not sound like actual conservatives on Twitter.

  2. No real network effects: Real Twitter has follower graphs, algorithmic amplification, bots, quote-tweet dunking culture. This simulation has none of that. Viral dynamics are approximated, not modeled.

  3. Context window limits: 200 personas × 5 rounds = a lot of text. Later rounds may lose early context. Use the SQLite database as the source of truth, not the model's memory.

  4. Not statistically rigorous: This is a thought experiment at scale, not a scientific poll. The demographic matching helps, but 100 AI personas are not 100 real people. Treat confidence scores as relative, not absolute.

  5. Cost scales linearly: More personas or more rounds = more tokens = more cost. The sweet spot is 100 personas × 5 rounds (~$8-12 with Sonnet).

Example: "How will Twitter react to osModa launching at $14.99/month?"

Phase 2 output (sample personas):

  • @devops_dan, 38, SRE at fintech, moderate, $120k — "I pay $20/mo for a Hetzner VPS. Why would I pay for an AI wrapper?"
  • @sarahbuilds, 26, indie hacker, progressive, $45k — "Wait this actually manages my server? I hate DevOps. Take my money."
  • @crypto_mike, 31, DeFi trader, libertarian, $200k+ — "Does it have wallet support? Can it run validators?"
  • @linux_grandpa, 62, retired sysadmin, conservative, pension — "Another AI grift. Learn bash."

Phase 3 results (after 5 rounds):

  • Support: 42%, Oppose: 31%, Mixed: 18%, Jokes: 9%
  • Fault line: Devs with sysadmin skills oppose (they don't need it). Non-technical builders support (they hate server management).
  • Viral argument: "It's not replacing sysadmins, it's giving non-technical people sysadmin superpowers" — shifted 12 positions.
  • Prediction: Positive reception among indie hackers and AI-tool-users. Skepticism from traditional DevOps. Price point acceptable for target audience.

© bolivian-peru, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/scaled-swarm-predict of bolivian-peru/os-moda.

Open the folder on GitHubat commit b8e418f

Compare with similar skills

Scaled Swarm Predict next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Scaled Swarm Predict compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Scaled Swarm Predict this skillbolivian-peru/os-moda119—~4.2kAutomated safety check: PassApache-2.0
Agent ReachPanniantong/Agent-Reach95k—~1.4kAutomated safety check: PassMIT
bb-browser Site Commands for OpenClawepiral/bb-browser6.2k—~1kAutomated safety check: PassMIT
Content CollectorvigorX777/content-collector-skill240—~2kAutomated safety check: PassNone
Influencer Discoverytigerless-labs/influencer-discovery212—~2.5kAutomated safety check: NotesNone
Qiaomu Opencli Usagejoeseesun/qiaomu-opencli-skills993—~3kAutomated safety check: PassMIT

Similar skills

  • Agent Reach

    Panniantong/Agent-Reach

    Routes web research and platform lookups across 16 sites, including Twitter, Reddit, YouTube, Bilibili, Xiaohongshu and GitHub, through one command-line tool.

    95k GitHub stars~1.4k tokensUpdated 3 days ago
    Productivity & AutomationAuto-check passed
  • Runs structured data commands against sites such as Twitter, Reddit, GitHub, YouTube and Zhihu through OpenClaw's browser, reusing your existing login state.

    6.2k GitHub stars~1k tokensUpdated 4 mo ago
    Productivity & AutomationAuto-check passed
  • Content Collector

    vigorX777/content-collector-skill

    Collect social media content (X/Twitter, WeChat, Jike, Reddit, etc.) into Feishu bitable.

    240 GitHub stars~2k tokensUpdated 6 mo ago
    Productivity & AutomationAuto-check passed
  • Influencer Discovery

    tigerless-labs/influencer-discovery

    Find the bloggers/creators who can help promote your work, capture their contact info, and append them to the target sheet in Google Sheets.

    212 GitHub stars~2.5k tokensUpdated 18 days ago
    Marketing & SEOAuto-check: notes
  • Qiaomu Opencli Usage

    joeseesun/qiaomu-opencli-skills

    A skill your agent uses when running OpenCLI commands to interact with websites (Bilibili, Twitter, Reddit, Xiaohongshu, etc.), desktop apps (Cursor, Notion), or public APIs (HackerNews, arXiv).

    993 GitHub stars~3k tokensUpdated 6 mo ago
    Research & ScienceAuto-check passed
  • Feedgrab Batch

    iBigQiang/feedgrab

    Batch content grabber — bulk fetch bookmarks, user tweets, search results, author notes, wiki pages, subreddit posts, and more from X/Twitter, Xiaohongshu, Reddit, WeChat, YouTube, Feishu, Zhihu.

    614 GitHub stars~1.8k tokensUpdated 1 mo ago
    Productivity & AutomationAuto-check passed

More from bolivian-peru/os-moda

All 17 skills in this repo
  • App Deployer

    bolivian-peru/os-moda

    Deploy and manage user applications as managed systemd services

    119 GitHub stars~774 tokensUpdated 3 mo ago
    Auto-check passed
  • Deploy AI Agent

    bolivian-peru/os-moda

    Deploy and manage AI agent workloads with GPU checks, API key management, and health monitoring

    119 GitHub stars~1.1k tokensUpdated 3 mo ago
    Auto-check passed
  • Drift Detection

    bolivian-peru/os-moda

    Detect configuration drift — manual changes that exist outside NixOS management.

    119 GitHub stars~584 tokensUpdated 3 mo ago
    Auto-check passed
  • Flight Recorder

    bolivian-peru/os-moda

    Black box flight recorder for the server. An agent skill from bolivian-peru/os-moda.

    119 GitHub stars~624 tokensUpdated 3 mo ago
    Auto-check passed
  • Generation Timeline

    bolivian-peru/os-moda

    NixOS generation-aware debugging and time-travel. An agent skill from bolivian-peru/os-moda.

    119 GitHub stars~777 tokensUpdated 3 mo ago
    Auto-check passed
  • Morning Briefing

    bolivian-peru/os-moda

    Generate a concise daily infrastructure briefing. An agent skill from bolivian-peru/os-moda.

    119 GitHub stars~897 tokensUpdated 3 mo ago
    Auto-check passed

Questions about Scaled Swarm Predict

What does Scaled Swarm Predict do?

Large-scale social simulation with 50-200 demographically diverse AI personas debating on a simulated Twitter/Reddit board to predict outcomes. Scaled Swarm Predict is an agent skill from bolivian-peru/os-moda.

How do I install Scaled Swarm Predict in Claude Code?

Run `npx skills add bolivian-peru/os-moda --skill scaled-swarm-predict -a claude-code`. Or copy the skill folder (skills/scaled-swarm-predict in bolivian-peru/os-moda) into .claude/skills/scaled-swarm-predict in your project. Claude Code loads it when a task matches its description.

How do I install Scaled Swarm Predict in Codex?

Run `npx skills add bolivian-peru/os-moda --skill scaled-swarm-predict -a codex`. Or copy the skill folder (skills/scaled-swarm-predict in bolivian-peru/os-moda) into .agents/skills/scaled-swarm-predict in your project. Codex loads it when a task matches its description.

Can I use Scaled Swarm Predict in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add bolivian-peru/os-moda --skill scaled-swarm-predict -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/scaled-swarm-predict, .gemini/skills/scaled-swarm-predict, .github/skills/scaled-swarm-predict and .opencode/skills/scaled-swarm-predict in your project.

What does Scaled Swarm Predict need to run?

Going by SKILL.md and its folder, Scaled Swarm Predict needs the command-line tools its instructions call (sqlite3 and make).

Does Scaled Swarm Predict access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Scaled Swarm Predict safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Scaled Swarm Predict use?

Scaled Swarm Predict is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Scaled Swarm Predict use?

About 4.2k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Scaled Swarm Predict?

Skills that share tags, products or a category with Scaled Swarm Predict: Agent Reach (Panniantong/Agent-Reach, 95k stars), bb-browser Site Commands for OpenClaw (epiral/bb-browser, 6.2k stars), Content Collector (vigorX777/content-collector-skill, 240 stars) and Influencer Discovery (tigerless-labs/influencer-discovery, 212 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Scaled Swarm Predict?

bolivian-peru (a GitHub user) maintains it in bolivian-peru/os-moda, which has 119 GitHub stars. The repository holds 17 skills in this directory. The repository was last updated on June 24, 2026.

Source: bolivian-peru/os-moda on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.