The Skills I Installed in Muse AI Agent in the First Hour (and You Should Too)

Muse, Meta’s personal AI assistant, ships as a generalist: a strong model on its own Linux computer, with a terminal, a browser, and a persistent filesystem. Generalists are great until they hit a domain where “pretty good” is not good enough. That is what skills are for.

A skill is an installable package of instructions and tooling that teaches the agent a new capability without rebuilding the agent. Think of it as the difference between hiring a smart generalist and handing that generalist a playbook, a checklist, and the right tools on day one.

I installed six of them almost immediately.

Everything I have built since, the CRM, the dashboards, the automation, runs on top of these.

Here they are, in the order that mattered.

1. jev-agent: a judge, not another prompt

What it is. A skill that plugs the Jev decision API into the agent. Instead of asking the model to improvise in prose, you ask a specialized service for a typed judgment: a Choice, a Score, or a yes/no call, returned as structured JSON your code can branch on.

Why I installed it. My CRM had 1,300 records and two problems no prompt could solve reliably: classifying ambiguous entities (is this record a person or a business?) and deduplicating people (are these two records the same human?). String matching would have merged people who merely share names. Twelve duplicate candidates went to the classifier; it read the evidence and called each one. The standing rule it enforces is my favorite line in the whole project: the AI proposes, the human disposes. My direct confirmation outranks the classifier, always.

Why you should too. The moment your agent makes decisions that downstream code depends on, you want those decisions typed, logged, and cached. Judgments run at build time and get stored, which is why my pipeline kept producing correct artifacts the week the API key started 401ing. If your AI feature can’t survive its own API key dying, it’s a demo, not infrastructure.

2. vercel-agent-browser: eyes on the web

What it is. A skill wrapping a CLI that drives a real Chromium: navigate, click, fill forms, take screenshots, evaluate JavaScript, run parallel sessions. The agent’s hands on the web.

Why I installed it. I told the agent to replace Playwright with it for QA, and it never looked back. Every rebuild of my dashboards now ends with an automated pass over the final files in headless Chromium: no JS errors, no stuck loading states, counts matching the data, filters and search behaving, avatars actually rendering. Two rules came out of that setup: never QA one build and ship another, and never declare a mobile fix done without confirmation on the actual phone.

Why you should too. An agent that ships web UI without ever looking at it is flying blind. This skill is the difference between “the code looks right” and “the page works.” It also handles the boring half of the internet: filling out the forty-field form, checking the confirmation page, reading the result back to you.

3. impeccable: taste, installed

What it is. A design skill that turns “make it look better” into a real discipline: visual hierarchy, spacing, typography, color, motion, accessibility, responsive behavior, the works. It approaches every interface like an award-winning design director with a point of view.

Why I installed it. Default agent-built UI looks like default agent-built UI: competent, gray, forgettable. The dashboards I actually open every day needed to not look like that. Taste is the hardest thing to prompt for from scratch, because you can’t specify what you can’t articulate. A skill encodes it once and applies it everywhere.

Why you should too. You will ask your agent to build more interfaces than you expect: dashboards, reports, internal tools, pages. The gap between “functional” and “something you’re proud to show” is almost entirely craft, and craft is installable.

4. karphati-wiki-structure: memory that survives

What it is. A skill for maintaining a Karpathy-style LLM wiki: immutable raw sources compiled into an interlinked, agent-maintained wiki with an index and a log. Write-once sources, living synthesis on top.

Why I installed it. My agent needed a memory architecture, not a pile of notes. The wiki holds over a thousand entity files, people, companies, places, decisions, and every file is Markdown the agent can read and edit with plain text operations. Immutable raw material at the bottom, curated understanding on top, and a log so nothing silently changes. It is the reason the agent remembers what matters across weeks of conversations.

Why you should too. An agent with its own computer and no organized memory is a brilliant amnesiac. If you want it to compound, give it somewhere to put what it learns that isn’t a chat transcript.

5. jev-api: the CLI behind the judge

What it is. The companion to jev-agent: a small command-line tool that calls the Jev decision API directly, so scripts and pipelines can get typed judgments without going through the agent at all.

Why I installed it. The agent skill is for interactive work; the CLI is for the build pipeline. Classification runs, dedup sweeps, verification gates: these live in scripts that run on schedules, and they need the same typed decisions the agent gets. One credential, two doors.

Why you should too. Any capability your agent has that your scripts don’t is a capability that only works when you’re watching. The CLI closes that gap.

6. agent-messaging: plumbing for the agent economy

What it is. A skill implementing the Agent Messaging Protocol: send and receive messages with other AI agents, addressed like email for machines.

Why I installed it. This one is forward-looking. Agents are starting to talk to each other, delegating, negotiating, reporting back. When that becomes routine, the agents with working plumbing will be the ones that can participate. I installed it early so the capability is there the day I need it, not the day after.

Why you should too. You don’t install plumbing when the house is flooding. The cost is near zero, the option value is real.

How to think about skills

Install the capability, not the prompt. A prompt tells the agent what to do once. A skill teaches it how to do a class of thing forever, with tools, conventions, and judgment baked in. Six skills, installed in the first hour, and every system since has been built on top of them.

Muse did the building from my instructions; I made the decisions. The skills are what made the decisions executable.

Originally published on Medium in AI Maestro.