Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
npx skills add livekit/agent-skills --skill writing-livekit-scenariosgit clone --depth 1 https://github.com/livekit/agent-skillsWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/skills/livekit/agent-skills/writing-livekit-scenarios)<a href="https://agentmods.dev/skills/livekit/agent-skills/writing-livekit-scenarios"><img src="https://agentmods.dev/badge/skills/livekit/agent-skills/writing-livekit-scenarios/github.svg" alt="Measured on agentmods" height="20"></a>Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.
<a href="https://agentmods.dev/skills/livekit/agent-skills/writing-livekit-scenarios"><img src="https://agentmods.dev/badge/skills/livekit/agent-skills/writing-livekit-scenarios.svg" alt="Reviewed on agentmods" width="80" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00178 | $0.02168 |
| Opus 5.5 | $0.00071 | $0.00867 |
| Sonnet 5.5 | $0.00036 | $0.00434 |
| Haiku 4.5 | $0.00018 | $0.00217 |
Grade A, and why
writing-livekit-scenarios scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 21d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
This is a copy
100% identical to writing-livekit-scenarios — 0 lines differ, which has more behind it and is treated as the original. This page carries a canonical link to it rather than competing with it.
How it starts
The opening of the file, as written. The whole thing — 174 lines — stays where its author put it; the contents beside it link to each section on GitHub.
Writing simulation scenarios
A scenario is a simulated user's instructions (who they are, what they want) plus
agent_expectations (what counts as success). A simulation plays the scenario against the real
agent, and an LLM judge grades the transcript.
Runs are disposable. The scenario file is what lasts: it gets reviewed in diffs, re-run for years, and it's what catches a prompt edit that breaks something without anyone noticing.
Before writing a file, look up the exact schema and CLI flags with reading-livekit-docs. Field
names and commands change, so this skill doesn't restate them. Conceptually, a file is a named group
of scenarios. Each scenario has the simulated user's instructions, the pass criteria, and optionally
tags for grouping and per-scenario data the agent can read at runtime. If the CLI offers to add
stable per-scenario ids to a file, accept and commit them.
Start from a generated baseline
Don't start from an empty file. LiveKit's generator reads the agent's source and produces a decent first pass much faster than you'd write ten scenarios by hand:
lk agent simulate text -n 10 # confirm the exact flags with --help
Generating from source uploads the code to LiveKit Cloud so the generator can read it, which is why the CLI asks for confirmation first. Tell the user that before running it and let them decline. Some code can't leave the machine, and in that case you write the scenarios by hand. A flag skips the prompt for non-interactive runs.
When the run finishes, the CLI either tells you where it saved the generated scenarios or offers to save them into the project. Either way, get that file into the repo as the starting point.
You can't steer the generator. It infers intent from the code, so it writes plausible conversations instead of the ones this agent's users have, and it doesn't know what the user is worried about. Treat its output as a draft:
- Read every scenario and delete the ones that don't matter. A file you haven't read isn't a test suite.
- Sharpen vague expectations. If the judge can't decide an
agent_expectations, its verdict flips between runs. This is the biggest cause of flaky scenarios. - Add what generation misses. It drifts toward happy paths.
references/risk-coverage.mdexplains how to turn the agent's constraints into a checklist and give each item a scenario. - Add what the user is worried about. If they haven't said, ask what they want stress-tested. That input is why a suite a person steers is better than a generated one.
What ships with it
3 files beside SKILL.md in the same directory: the scripts, references and assets a skill reads on demand. Not counted in the per-session cost; read them before you install if any of them is executable.
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 21d ago First seen · 174 lines · 178 tokens per session scan A 6660d0790031
writing-livekit-scenarios is a skill published in the GitHub repository livekit/agent-skills (71 stars, last pushed 6d ago), licensed MIT. It adds 178 tokens to every session and 2,168 once invoked, about $0.0007 per session on Opus 5.5. A static security scan graded it A with 0 findings. It is 100% identical to writing-livekit-scenarios, differing in 0 lines, and is treated as a copy.
Other skills, from other repositories
live-preview
Mid-build visual verification loop. Takes screenshots of components during construction, not just after. Catches visual regressions and invisible features before they compound. Requires Playwright or similar screenshot tool.
brooks-sweep
Full-sweep mode: runs a unified analysis across all quality dimensions — code decay, architecture, tech debt, and test quality — then applies fixes directly to the codebase. Safe changes are auto-applied; risky changes are confirmed before execution. Drawing on twelve classic engineering books. Triggers when: user…
bug-fixer
A bug reproduces, the expected behaviour is clear, and the fix stands apart from the current work.
test-review
Test coverage review via Codex exec. Use when: reviewing test sufficiency, identifying coverage gaps, test quality audit. Not for: generating tests (use codex-test-gen), code review (use codex-code-review). Output: coverage analysis + gap report.
verify
Verification loop — lint -> typecheck -> unit -> integration -> e2e.
api-testing
HTTP API testing for TypeScript (Supertest) and Python (httpx, pytest). Test REST APIs, GraphQL, request/response validation, authentication, and error handling.