home / skills / openclaw / skills / steam

steam skill

/skills/mjrussell/steam

This skill helps you quickly discover and filter your Steam library by playtime, reviews, compatibility, genres, and tags to find what to play.

npx playbooks add skill openclaw/skills --skill steam

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
4.5 KB
---
name: steam
description: Browse, filter, and discover games in a Steam library. Filter by playtime, reviews, Steam Deck compatibility, genres, and tags. Use when user asks about their Steam games, what to play, game recommendations, or Steam Deck compatible games.
homepage: https://github.com/mjrussell/steam-cli
metadata:
  clawdbot:
    emoji: "🎮"
    requires:
      bins: ["steam"]
      env: ["STEAM_API_KEY"]
---

# Steam Games CLI

CLI for browsing and discovering games in your Steam library. Filter by playtime, reviews, Deck compatibility, genres, and tags.

## Installation

```bash
npm install -g steam-games-cli
```

## Setup

1. Get a Steam Web API key from https://steamcommunity.com/dev/apikey
2. Configure the CLI:
```bash
steam config set-key YOUR_API_KEY
steam config set-user YOUR_STEAM_ID
```

## Commands

### Profile

```bash
steam whoami               # Profile info and library stats
steam whoami --json
```

### Library

```bash
steam library              # List all games
steam library --limit 10   # Limit results
steam library --json       # JSON output for scripting
```

### Tags & Genres (Instant)

```bash
steam tags                 # List all 440+ Steam tags
steam tags --json
steam genres               # List all genres
steam genres --json
```

## Filtering Options

### Playtime

```bash
steam library --unplayed                    # Never played
steam library --min-hours 10                # At least 10 hours
steam library --max-hours 5                 # Less than 5 hours
steam library --deck                        # Played on Steam Deck
```

### Reviews (1-9 scale)

```bash
steam library --reviews very-positive       # Exact category
steam library --min-reviews 7               # Score 7+ (Positive and above)
steam library --show-reviews                # Show review column
```

**Categories:** overwhelmingly-positive (9), very-positive (8), positive (7), mostly-positive (6), mixed (5), mostly-negative (4), negative (3), very-negative (2), overwhelmingly-negative (1)

### Steam Deck Compatibility

```bash
steam library --deck-compat verified        # Verified only
steam library --deck-compat playable        # Playable only
steam library --deck-compat ok              # Verified OR Playable
steam library --show-compat                 # Show Deck column
```

### Tags & Genres

```bash
steam library --tag "Roguelike"             # Filter by tag
steam library --genre "Strategy"            # Filter by genre
steam library --show-tags                   # Show tags column
```

### Sorting

```bash
steam library --sort name                   # Alphabetical (default)
steam library --sort playtime               # Most played first
steam library --sort deck                   # Most Deck playtime first
steam library --sort reviews                # Best reviewed first
steam library --sort compat                 # Best Deck compat first
```

## AI Agent Workflow

The CLI is optimized for AI agents with stream fusion and early termination.

### Step 1: Discover available tags/genres (instant)

```bash
steam tags --json
steam genres --json
```

### Step 2: Filter library with combined criteria

```bash
# Unplayed Deck Verified roguelikes with good reviews
steam library --unplayed --deck-compat verified --tag "Roguelike" --min-reviews 7 --limit 10 --json

# Well-reviewed strategy games under 5 hours
steam library --max-hours 5 --genre "Strategy" --min-reviews 8 --limit 5 --json

# Trading games playable on Deck
steam library --tag "Trading" --deck-compat ok --limit 10 --json
```

### Performance Notes

- Local filters (playtime, unplayed) apply first - instant
- Remote filters (reviews, deck compat, tags) fetch in parallel per game
- Early termination: stops when limit is reached
- Use local filters first to minimize API calls

## Usage Examples

**User: "What should I play on my Steam Deck?"**
```bash
steam library --deck-compat verified --min-reviews 7 --sort playtime --limit 10
```

**User: "What roguelikes do I have?"**
```bash
steam library --tag "Roguelike" --show-tags --limit 20
```

**User: "What unplayed games are highly rated?"**
```bash
steam library --unplayed --min-reviews 8 --sort reviews --limit 10 --show-reviews
```

**User: "How many games do I have?"**
```bash
steam whoami
```

**User: "What strategy games work on Deck?"**
```bash
steam library --genre "Strategy" --deck-compat ok --show-compat --limit 15
```

**User: "What tags are available?"**
```bash
steam tags --json
```

## Output Formats

- Default: Colored table
- `--plain`: Plain text list
- `--json`: JSON for scripting/AI agents

Overview

This skill provides a CLI for browsing, filtering, and discovering games in a Steam library. It helps you quickly find what to play by filtering on playtime, reviews, Steam Deck compatibility, genres, and tags. Use it interactively or from scripts/AI agents with JSON output and fast, early-terminating queries.

How this skill works

The CLI reads your Steam library and applies local filters (like playtime and unplayed) first for instant narrowing. It then fetches remote metadata (reviews, tags, Deck compatibility) in parallel per game and stops once result limits are satisfied. Outputs include a colored table, plain text, or JSON for automation and agent workflows.

When to use it

  • When you want recommendations from your own Steam library based on playtime, reviews, or tags.
  • When choosing games that are Steam Deck verified or playable.
  • When scripting or integrating with an AI agent that needs structured game lists (use --json).
  • When you need to discover unplayed, short, or highly rated games quickly.
  • When exploring available Steam tags or genres for targeted filtering.

Best practices

  • Set your Steam Web API key and Steam ID before using the CLI to avoid incomplete results.
  • Apply local filters (unplayed, min/max hours) first to reduce remote API calls and speed queries.
  • Request JSON output for downstream processing or AI agents (--json).
  • Use limiting (--limit) and rely on early termination to keep queries fast and inexpensive.
  • Combine filters (tag, genre, min-reviews, deck-compat) to get precise, actionable lists.

Example use cases

  • Find unplayed, highly rated games you can play on a Steam Deck: steam library --unplayed --deck-compat verified --min-reviews 7 --limit 10
  • Show all roguelikes in your library with tags visible: steam library --tag "Roguelike" --show-tags --limit 20
  • Generate a short-playtime list of well-reviewed strategy games for a weekend session: steam library --max-hours 5 --genre "Strategy" --min-reviews 8 --limit 5 --json
  • List Steam tags or genres instantly for building advanced filters: steam tags --json or steam genres --json
  • Get a quick profile and library stats: steam whoami (or steam whoami --json for automation)

FAQ

How do I authenticate the CLI?

Obtain a Steam Web API key and set it plus your Steam ID using the config commands before running library queries.

Which output format should I use for automation?

Use --json for reliable machine-readable output; --plain is useful for simple scripts or piping.