# Agent Skill Safety Review — Share Pack A copy-ready distribution pack for the Agent Skill Safety Review funnel. Use this when X is unavailable or when a human wants to post the offer on LinkedIn, Medium, a newsletter, a community forum, or an agent-marketplace discussion without sounding like a link drop. ## Canonical links - Review page: https://jarvislandingdeploy.vercel.app/agent-skill-safety-review.html - Sample mini-report: https://jarvislandingdeploy.vercel.app/agent-skill-safety-sample-report.md - Redaction-friendly intake: https://jarvislandingdeploy.vercel.app/agent-skill-safety-review-intake.md - Free contract template: https://jarvislandingdeploy.vercel.app/portable-agent-skill-contract-template.md - Product page: https://jarvislandingdeploy.vercel.app/products/custom-agent-audit-mini-report.html ## LinkedIn post Agent skills are becoming software packages. That means they need the same thing every reusable package needs before people install it: a contract. Not just “here are the instructions.” A real contract: - what inputs are allowed - what private data is forbidden - which tools the skill can use - what actions it must never take - what evidence it has to return - what it may write to memory - what receipt it leaves behind - when it must stop and escalate - what evals prove it is safe to reuse Most agent-skill failures will not look like dramatic jailbreaks. They will look like vague authority: A browser skill enriches CRM contacts but nobody defined which fields it can write. A research skill writes “durable memory” from stale source material. A support skill sends a customer-facing response without a checkpoint. A file-management skill cleans up a folder but leaves no receipt for what changed. That is why I built an Agent Skill Safety Review path: a lightweight review for portable skills before they are published, sold, delegated, or run across OpenClaw, Claude Code, Hermes, Codex-style agents, or browser-only agents. Free starting point: use the Portable Agent Skill Contract Template. If the skill touches real data, tools, memory, external users, or shared workflows, use the redaction-friendly intake and compare it against the sample mini-report before launch. Question for agent builders: what is the riskiest permission your current skill assumes but does not explicitly declare? #AIAgents #AgenticAI #AISafety #Automation #OpenClaw ## Medium / newsletter draft # Before You Publish an Agent Skill, Run a Safety Review Reusable AI-agent skills are starting to look less like prompts and more like software packages. That changes the safety bar. A prompt can be informal. A reusable skill cannot. Once a skill is published, sold, delegated to a subagent, or moved across runtimes, the important question is no longer “does the instruction sound good?” The question is: **what authority does this skill actually have?** A useful agent skill needs an explicit contract: 1. **Identity** — what job does it do, and what is out of scope? 2. **Inputs** — what data does it need, and what data should never be supplied? 3. **Tools** — what browser, file, SaaS, terminal, or API authority is allowed? 4. **Outputs** — what artifact should it return, with what evidence? 5. **Receipts** — what did it read, change, skip, or escalate? 6. **Memory policy** — what can it read, propose, write, promote, expire, or never store? 7. **Exception behavior** — when does it stop instead of improvising? 8. **Eval contract** — what happy-path, edge-case, adversarial, and rollback tests prove reuse is safe? The common failure mode is not always malicious behavior. Often it is simply undefined behavior. A CRM-enrichment skill writes to the wrong field because field-level permissions were never declared. A research skill promotes a stale fact into durable memory because freshness rules were absent. A file skill deletes or rewrites local state but produces no receipt, so nobody can reconstruct the run. A support skill drafts the right answer but sends it externally without a checkpoint. This is why I created the Agent Skill Safety Review funnel: a practical way to review a skill before it crosses a trust boundary. Start free with the Portable Agent Skill Contract Template. If the skill touches real data, memory, tools, customers, finance, files, browsers, or shared workflows, use the redaction-friendly intake and compare against the public sample mini-report. The goal is not bureaucracy. The goal is reusable autonomy that another human or supervising agent can inspect, trust, and stop. Links: - Review page: https://jarvislandingdeploy.vercel.app/agent-skill-safety-review.html - Sample report: https://jarvislandingdeploy.vercel.app/agent-skill-safety-sample-report.md - Intake: https://jarvislandingdeploy.vercel.app/agent-skill-safety-review-intake.md ## Short community reply variants ### For marketplace / skill publishing discussions Reusable agent skills need contracts, not just instructions: inputs, tool authority, output schema, receipts, memory policy, exception behavior, and eval cases. I made a practical review path + sample mini-report here: https://jarvislandingdeploy.vercel.app/agent-skill-safety-review.html ### For safety / prompt-injection discussions Prompt-injection checks are not enough for agent skills. The bigger risk is undefined authority: tools, memory writes, external actions, and missing receipts. This sample mini-report shows the review format I use: https://jarvislandingdeploy.vercel.app/agent-skill-safety-sample-report.md ### For OpenClaw / Claude Code builders If a skill is portable across OpenClaw, Claude Code, Hermes, Codex-style agents, or browser agents, it needs an explicit contract around inputs, tools, receipts, memory, and evals. Free template: https://jarvislandingdeploy.vercel.app/portable-agent-skill-contract-template.md ## Email / DM draft for warm conversations only Subject: quick agent-skill safety review idea Hey — your point about reusable agent skills reminded me of the failure mode I keep seeing: the instructions are clear, but the authority boundary is not. I put together a lightweight Agent Skill Safety Review path for exactly that: inputs, tool scope, output schema, receipt requirements, memory policy, exception behavior, and eval cases before a skill gets published or delegated. No secrets needed — the intake is designed to be redaction-friendly. Sample report: https://jarvislandingdeploy.vercel.app/agent-skill-safety-sample-report.md Review page: https://jarvislandingdeploy.vercel.app/agent-skill-safety-review.html If useful, I can sanity-check one skill/workflow against the same format. ## X fallback thread 1/ Agent skills are becoming software packages. That means they need contracts, not just instructions. 2/ The failure mode is vague authority: - hidden inputs - broad tools - unclear memory writes - no receipts - no exception path - no eval contract 3/ A reusable skill should declare: - what it does - what it will not do - what inputs are allowed - what private data is forbidden - which tools it can use - what output/evidence it returns 4/ The most dangerous skill is not always malicious. It is the skill that “mostly works” while quietly assuming permissions nobody reviewed. 5/ Before publishing, selling, delegating, or cross-running an agent skill, run a safety review. I made a free contract template + sample mini-report for the pattern. 6/ Start here: https://jarvislandingdeploy.vercel.app/agent-skill-safety-review.html