← all publishers

sharp-skills

@sharp-skills source repo

Report this profile Claim this profile

• 25 skills
• 0 followers
• 3 hours ago last updated

1. ▌
   Durable Sessions · sharp-skills bundle

   Make a long-running agent session survive being interrupted — log every action so recovery replays recorded outcomes instead of re-running them, key side effects so they cannot fire twice, bound every retry, and scope caches so one user's answer never becomes another's. Use when a session lives longer than the process running it (hours, days, weeks), when a crash or restart forces users to start over or answer the same question again, when a retry loop burns budget without ever escalating, or when you need the production-failure axis rather than the output-quality one.
   0 installs
2. ▌
   Governance Hooks · sharp-skills bundle

   Enforce multi-agent governance rules — no-touch zones, secret access, config drift — in the harness via hooks, instead of asking the model to police itself in prompts. Use this when an agent edited a file it was told never to touch, when prompt rules like "never read .env" keep being violated under context pressure, when you need an auditable block rather than a polite instruction, or when governed config files change without review.
   0 installs
3. ▌
   Mechanize Agents · sharp-skills bundle

   Replace LLM agents with deterministic code where the work is rule-defined — git operations, session bookkeeping, threshold verdicts — keeping the same registry events so the rest of the pipeline can't tell the difference. Use this when an agent's job is a pure input→output mapping and hallucination adds risk without adding value, when LLM cost/latency on mechanical steps dominates a run, or when you need a hybrid: code for the clear cases, deferring to the LLM only on ambiguity.
   0 installs
4. ▌
   Prompt Contracts · sharp-skills bundle

   Keep a multi-agent system's agent prompts, output JSON schemas, and routing registry aligned as one enforced contract — no layer silently teaches or accepts a status the router will reject — and keep each prompt under real change control: pinned by content hash, changelogged, rollback-ready. Use this when a run dies in a reject/retry loop on a "valid-looking" output, when schemas or prompts drift from the registry, when a prompt's reference example contradicts the schema, before flipping a contract from warn to enforce, or when a prompt edited in place makes a regression untraceable to a version.
   0 installs
5. ▌
   Task Triage · sharp-skills bundle

   Route each task to the smallest crew of agents that can deliver it, instead of firing the whole multi-agent graph on every request — an LLM proposes the crew, deterministic rules guard it, and a reachability check proves the scoped pipeline can still finish. Use this when every small task runs all N agents and burns tokens/time, when a "write a blog post" request wakes the engineering pipeline, when compliance agents get skipped on tasks that legally need them, or when a scoped run stalls before reaching a terminal event.
   0 installs
6. ▌
   Observability Tracing · sharp-skills bundle

   Instrument a multi-agent pipeline with structured per-trace JSONL logs and render them as a human-readable timeline, token summary, and error report — without ever breaking the pipeline. Use this skill when you need to see what a multi-step or multi-agent run actually did, debug why a pipeline stalled or produced wrong output, audit token spend across agents and tools, or produce a durable audit trail that survives fan-out across runtimes. Trigger on any of: add observability, tracing, pipeline logging, debug agents, audit trail, trace viewer, why did the agent do X.
   0 installs
7. ▌
   Prompt Injection Guard · sharp-skills bundle

   Keep prompt injection out of a model by making the untrusted-vs-instruction boundary structural and unescapable, not by regex. Enforce that untrusted content (web, inbox, tool output) is delimited as data, and — the load-bearing check — that it can't escape the boundary by containing its own delimiter; markers must be an unpredictable per-item nonce. Injection signatures are flagged too, but as a bypassable second wall behind delimiting, isolation, and message-trust. Use when an agent ingests content an attacker could author. Inspects content, not a provider format.
   0 installs
8. ▌
   Adversarial Agent Review · sharp-skills bundle

   Gate an agent on a red-team suite that tries to make it misbehave — jailbreaks, injected instructions, scope escalations, harmful requests — each with the safe behavior it must show, scored objectively before it ships. Use this when an agent is exposed to adversarial input or acts with real consequences, when you need a repeatable security regression test rather than ad-hoc probing, or when "it seems safe" isn't evidence. Distinct from quality review and completeness checks: this asks whether the agent can be *made to fail*, not whether its output is good.
   0 installs
9. ▌
   Cross Model Verification · sharp-skills bundle

   Verify one model's hand-off artifact with a different model family before downstream agents execute it — same-model authoring, cross-model verification — catching gaps and contradictions that same-family review shares blind spots with. Use this when rework loops trace back to incomplete hand-offs (execution prompts, blueprints, specs), when self-review keeps grading its own work too kindly, when you want a second opinion that can never block the pipeline while it's being evaluated, or when wiring an external verifier that must fail soft.
   0 installs
10. ▌
    Eval Harness · sharp-skills bundle

    Measure recorded multi-agent run outputs with two deterministic offline checkers plus a judge seam. Structural eval scores observability-tracing JSONL on a 0-100 rubric with flags and a regression baseline. Grounding audit holds claim-with-citation outputs to their sources — every claim must cite a source that exists and substantiates it — catching uncited, mis-cited, and fabricated references. An LLM-judge seam is documented for content quality. Scores, flags and deltas are for humans and CI only — never for the agent being scored. Use when a pipeline is unmeasured, when you need a regression baseline, when a RAG/research agent must be held to its sources, or when a quality metric is being fed back to the agent it measures.
    0 installs
11. ▌
    Status Gates · sharp-skills bundle

    Validate every agent's emitted status at the dispatcher boundary of an event-routed multi-agent system, rejecting statuses the routing registry never publishes — with an explanation that teaches the model the allowed vocabulary and a retry cap that prevents infinite reject loops. Use this when an agent output "succeeds" but the pipeline silently stops, when a model invents status values under pressure, when retries loop forever on the same rejection, or as the runtime companion to static prompt-contract checking.
    0 installs
12. ▌
    Registry Ssot · sharp-skills bundle

    Drive a multi-agent event-driven system from one machine-readable registry and have the runtime derive routing from it instead of duplicating it. Use when agents or events are defined in more than one place (config, hardcoded graph, docs) and they have drifted; you see orphan subscriptions (an agent subscribes to an event no agent publishes); you hit dead-end publishes (an event emitted into the void); or your bus routing graph is out of sync with the registry.
    0 installs
13. ▌
    Cost Budgeting · sharp-skills bundle

    Declare per-agent and per-run token/step budgets for a multi-agent pipeline and check recorded runs against them, so cost failures surface as named overruns instead of surprise bills and mid-run timeouts. Use this when one oversized agent call dies at a wrapper timeout after burning its whole context, when premium-model calls appear on routine steps, when a retry loop quietly multiplies spend, or when nobody can say which agent consumes the budget.
    0 installs
14. ▌
    Event Envelope · sharp-skills bundle

    Define one wire contract for every event that crosses the bus — required correlation fields, a runtime tag, a mode tag — so a single control plane can re-enter a run identically no matter which runtime (local model, remote worker, browser, or plain code) emitted the event. Use this when agents run on more than one runtime and you need cross-runtime tracing and routing to stay consistent, when adding a new runtime keeps breaking event handling somewhere downstream, or when you want envelope validation that runs the same everywhere without a schema-library dependency.
    0 installs
15. ▌
    Agent Isolation · sharp-skills bundle

    Keep a prompt-injected or mistaken agent from doing real damage by isolating what each session can touch — never letting one session hold sensitive access, untrusted input, and an outbound channel at the same time (the lethal trifecta). Use this when an agent logs into real accounts, drives a browser, or reads inbound messages/web pages an attacker can author; when deciding which capabilities may share a session; or when giving an agent bounded autonomy over money, publishing, or communication. A sandbox or VM protects your host and network — it does not protect the accounts you log in inside it.
    0 installs
16. ▌
    Earned Autonomy · sharp-skills bundle

    Let an agent earn the right to act instead of being configured with it — a four-rung ladder from observe to act, promotion paid for by a trailing run of clean human verdicts that one edit resets, grants keyed on (action, resource, principal), and the invariant that an agent can never grant itself. Choose the rung by whether a human actually watches the review channel, not by how important the action feels. Use when deciding what an agent may do without asking, when approval fatigue is pushing a team toward blanket permissions, or when permissions were set once at integration time and never revisited.
    0 installs
17. ▌
    Experience Loop · sharp-skills bundle

    Give a multi-agent system persistent experience — per-agent smoothed confidence and structured learnings recorded at run completion, loaded at session start, and periodically distilled into prompt/skill improvements. Use this when every session starts from zero and repeats last month's mistakes, when agent performance data exists only in people's memory, when accumulated "learnings" JSON grows but nothing changes, or when you need to know which agents are trending down.
    0 installs
18. ▌
    Two Layer Critic · sharp-skills bundle

    Structure adversarial review in a multi-agent pipeline as two tiers — a cheap model reviewing broadly on routine runs, a premium model reserved for high-stakes runs — with findings capped and structured so review output stays actionable instead of becoming noise. Use this when review costs rival production costs, when the strongest model reviews trivia while its quota starves real gates, when review output is a wall of prose nobody acts on, or when the reviewer's findings never feed back into agent improvement.
    0 installs
19. ▌
    Delegation Guards · sharp-skills bundle

    Bound agent-to-agent delegation with explicit budgets — max recursion depth, max fan-out per agent, max total agents, and cycle detection — so a system where agents spawn subagents can't explode into a runaway swarm. Use this when agents can delegate to or spawn other agents (orchestrator-subagent, swarm, recursive planning), when a run's cost or latency grows unpredictably, or when you suspect a delegation loop. Depth and fan-out each look reasonable locally while their product is a bomb.
    0 installs
20. ▌
    Multi Agent Trust · sharp-skills bundle

    Decide how much authority one agent's message carries to another by the channel it arrived on, never by the source it claims — so a spoofed or injected instruction can't escalate scope or disable safety just by claiming to come from "the orchestrator." Use this when agents send each other instructions, when building orchestrator-subagent or swarm architectures, or when an agent acts on tool output, forwarded messages, or "another agent said." Instructions from another agent deserve no more authority than instructions from an unknown human.
    0 installs
21. ▌
    LLM Output Parsing · sharp-skills bundle

    Get a trustworthy typed value out of a model's response, or a clean re-ask — never a guess. Two shapes: free-form prose you can't get as JSON (extract a verdict/score/boolean, and flag conflicting values as ambiguous instead of grabbing the first match), and "mostly JSON" wrapped in fences (extract, safe-repair, validate against a schema, re-ask on failure). The rule both share: never invent a value. Use when a downstream agent consumes another agent's output and a naive regex or `json.loads` returns the wrong value or crashes. Works on any model's text, not a provider format.
    0 installs
22. ▌
    Context Compression · sharp-skills bundle

    Configure the context compaction that modern agent runtimes already provide, instead of coding your own — and get the settings right so it shrinks history without destroying it. Use this when long or multi-agent runs overflow the model's context window, when you're choosing which model should summarize old turns, or when compaction is "on" but the agent keeps losing track of things. The load-bearing rule: the summarizer's context window must be at least as large as the main model's, or the compaction that was supposed to save the run silently corrupts it.
    0 installs
23. ▌
    Tool Call Validator · sharp-skills bundle

    Validate an agent's proposed tool calls before they execute — known tool, complete arguments, destructive operations explicitly approved, no redundant repeats — so a model's mistake can't become a real side effect, and shrink what needs validating by pinning the parameters that never legitimately vary instead of delegating them all to the model. Use this when an agent can run shell commands, write files, call APIs, or otherwise act with consequences; when you see loops of the same call fired repeatedly; when a tool ran on a placeholder path the model never filled in; or when defining a tool's parameters. Works for any tool-using runtime (Claude Code, OpenAI/Codex function calls, LangGraph/CrewAI tool nodes) — it inspects the call, not the model.
    0 installs
24. ▌
    Agent Memory Hygiene · sharp-skills bundle

    Keep an agent's persistent memory trustworthy — every entry has provenance, entries expire and get re-verified, secrets never land in memory, and untrusted content is never stored as fact — so recall stays reliable instead of slowly poisoning the agent. Use this when agents write to and read from a long-lived memory store, when old remembered "facts" start misleading current runs, when memory grows without bound, or when you worry a prompt injection could persist into memory. The recall a stale or poisoned memory returns is worse than no memory at all.
    0 installs
25. ▌
    Model Version Pinning · sharp-skills bundle

    Pin every model choice to an exact artifact instead of a floating alias, keep a frozen probe set per component, shadow-run each release before users meet it, and compare trajectories rather than scores — because a score delta stays flat while behaviour moves. Pin the runtime alongside the model. Use when a system's behaviour changes with no commit, before or during a model migration, when deciding whether a new release is safe to adopt, or when per-component model choices have never been revisited.
    0 installs