Topic
#OpenClaw
Loot, blog posts and adjacent themes connected to this topic. Follow the tag to keep it in your orbit.
38Shown loot
10Shown articles
8Linked neighbor tags
Topic paths
If you want to go deeper, the adjacent tags are the fastest way to compare and branch into related workflows.
Loot
More from this topic
This item includes essential tools and setup for the OpenClaw Codex Harness, covering runtime configuration, tool discovery, and migration guidance. Ideal for users seeking structured access to the latest features. OpenClaw's Codex harness shift matters because it cleans up the runtime boundary between OpenAI agent turns and the rest of the OpenClaw stack. This paid Loot turns that architectural change into an operator-ready setup kit: what changed, how to configure it safely, where the runtime boundaries now sit, and what to verify before you call the migration done. What is inside A plain-English explanation of what the Codex harness changes in practice The correct subscription-auth login path for ChatGPT/Codex-backed agent use A runtime setup checklist for openai/ + native Codex execution A migration checklist for older openai-codex/ or PI-heavy setups A decision matrix for Codex runtime vs explicit PI fallback A tool-discovery and visible-replies interpretation guide A troubleshooting pass for runtime mismatch, auth confusion, and session isolation questions 1) The new mental model The cleanest way to understand this release is to stop thinking in terms of "OpenClaw does everything". Now there is a clearer split: Codex runtime owns the low-level OpenAI agent turn OpenClaw owns the surrounding operating system for the agent In practice that means Codex handles the native app-server side of the turn, while OpenClaw continues to own channels, persona, memory, scheduling, approvals, delivery rules, and the wider tool ecosystem. That matters because less translation usually means less friction. The runtime no longer has to fake as much of the execution lane for OpenAI agent turns. 2) The correct auth and setup path If the goal is "my ChatGPT/Codex subscription powers my OpenClaw agent", the official login path is: Then use canonical OpenAI model refs such as openai/gpt-5.5 and the Codex runtime path. Minimal config pattern: If you use a plugin allowlist, include codex there too. 3) What changed for tool usage One of the biggest practical wins is that tool loading can become less bloated and more selective. Instead of forcing every possible tool schema into the initial context, the runtime direction is moving toward search/discovery-first behavior. For operators, that matters because it improves three things at once: smaller initial context less schema clutter better odds that the model picks the right tool instead of the nearest noisy one That is not just a cost story. It is a reliability story. 4) Why visible replies feel cleaner now The Codex harness docs make a subtle but important point: visible replies default toward deliberate message-tool behavior unless the deployment explicitly chooses automatic reply behavior. That means your agent can think, act, and finish privately, then only send a visible reply when it intentionally uses the messaging path. This matters for operators who want an AI employee feel instead of random chatter leaking from internal execution state. 5) Runtime decision matrix Situation Best route Why --- --- --- You want ChatGPT/Codex subscription-powered OpenAI agent turns openai/gpt-5.5 + agentRuntime.id: "codex" Native first-class path You want a direct API-key backup Keep openai/gpt-5.5, add backup auth profile Preserves canonical route while giving redundancy You explicitly need legacy/compatibility behavior openai/gpt-5.5 + runtime pi Useful as an intentional fallback path You are migrating old openai-codex/ refs Repair to openai/ and verify runtime Cleaner current model/runtimes split 6) Migration checklist Use this when updating an existing OpenClaw install: [ ] Codex plugin is installed and enabled [ ] Subscription auth was logged in with openai-codex [ ] Primary agent model uses openai/gpt-5.5 or another current openai/ ref [ ] Agent runtime is explicitly codex where you want the native path forced [ ] Any legacy openai-codex/ model refs are reviewed or repaired [ ] Tool behavior is tested on one real workflow, not just a model list command [ ] Visible reply behavior is confirmed in the channel you actually use [ ] You know when to fall back to PI for compatibility reasons 7) Common operator mistakes Using the wrong auth provider name during login Assuming openai-codex/ should stay the main long-term model route Treating provider, runtime, and auth as one setting instead of three layers Claiming the migration is done before testing an actual multi-tool task Forgetting that quiet/private execution and visible replies are now more intentionally separated 8) Best use case Use this Loot if you are publishing about the 2026.5.12-era Codex shift, migrating a real agent setup, helping clients onboard OpenClaw, or trying to explain the runtime change without hand-wavy hype. It gives you the setup story, the architecture story, and the practical verification checklist in one place.
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
If you care about OpenClaw + wallet efficiency, the answer is not one universal winner. It depends on whether you want flat monthly cost, cheap API scale, or lowest policy risk. Fast ranking Best for Pick Why --------- best overall for solo OpenClaw use ChatGPT subscription (Codex OAuth) officially supported in OpenClaw docs, no API key needed, best flat-cost path best cheap API backend Kimi / Moonshot strong OpenClaw support, large context, good coding/agent positioning best ultra-budget API experiments DeepSeek simple API path, broad agent-tool compatibility, low-cost usage style safest enterprise-style path OpenAI or Anthropic API key cleanest policy story and least auth ambiguity riskiest subscription path Claude Pro/Max via setup-token technically works, but OpenClaw docs explicitly warn Anthropic has blocked some outside-Claude-Code subscription usage before What to avoid Claude subscription as your main production path if you hate policy risk any provider choice based only on benchmark hype without checking auth/support posture expensive API-first setups if your real usage is mostly personal agent workflows that fit better under a flat subscription Best pick by user type Solo tinkerer / daily driver: ChatGPT subscription Builder chasing cheap API throughput: Kimi Experimenter on strict budget: DeepSeek Team / production / compliance-sensitive: API keys, not subscriptions
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. Use ML/QSAR models to assess absorption, distribution, metabolism, excretion and toxicity for small molecules before expensive experimental testing. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does This OpenClaw skill predicts key pharmacokinetic and safety properties for drug-like compounds. It covers Absorption (Caco-2 permeability, HIA), Distribution (volume of distribution, plasma protein binding, blood-brain barrier penetration), Metabolism (cytochrome P450 interactions), Excretion (clearance, half-life) and Toxicity alerts (hERG inhibition, DILI risk, Ames mutagenicity). The tool outputs structured profiles with confidence scores and actionable recommendations, helping researchers filter large compound libraries against Lipinski, Veber and other drug-likeness rules. Who should use it Medicinal chemists, computational biologists and drug discovery teams who need rapid in-silico triage of candidate molecules. It is particularly useful for prioritizing synthesis efforts by flagging structural liabilities—such as potential hepatotoxicity or poor oral bioavailability—before committing resources to wet-lab assays. Setup surface The skill requires Python and the RDKit library (pip install rdkit). Optional advanced modeling capabilities depend on deepchem and admet-x. Users interact via command-line interfaces provided by the skill scripts, such as /admet "SMILESstring" --full for single-molecule analysis or batch processing using .sdf files. Documentation references specific model types (ML/QSAR) but does not specify which underlying algorithms are active without further inspection. Runner test plan Future validation will include static checks for dependency integrity and injection vulnerabilities. Testing will verify that script arguments parse correctly and that output formats match documented Markdown structures. Sandbox execution will confirm that predictions generate without runtime errors for known SMILES strings. No human review or live experimental comparison has occurred; all claims rely solely on the provided technical documentation. Risk notes Predictions are approximate and carry inherent uncertainty. Novel chemical scaffolds often fall outside model applicability domains, leading to unreliable results. The tool explicitly warns against over-reliance: experimental validation remains mandatory for critical decisions. In vitro-in vivo gaps mean computer-predicted clearance or toxicity may not translate directly to living systems. Species differences also affect accuracy, as many models train on animal data while targeting human outcomes. Low-confidence flags require immediate manual investigation rather than automated rejection. Source links Original skill documentation Skill listing
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. Discover inventory, launch display and video buys, and track ROI through an agent skill that speaks plain English instead of dashboard clicks. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does The AdCP Advertising skill connects OpenClaw agents to the Ad Context Protocol, letting marketing teams run programmatic campaigns without learning every ad platform's interface. You describe what you want in natural language—"find premium video placements for luxury brands" or "create a $10k display campaign targeting tech professionals in California"—and the skill handles discovery, creation, creative uploads, and performance tracking. It supports eight core operations: capability discovery, product search, format listing, media buy creation and updates, creative sync and retrieval, and delivery metrics. Pricing models include CPM, auction-based bidding, CPCV for video completions, flat fees, and cost-per-point. Targeting overlays cover geography, demographics, behavioral interests, and contextual keywords. Who should use it Media buyers managing multi-publisher spend, agencies automating client reporting, e-commerce brands launching retargeting campaigns, and startups running lean marketing budgets. The skill reduces manual setup time by replacing complex dashboards with conversational commands. If your team already uses Facebook or Google ads but struggles with cross-channel optimization, this abstracts those platforms behind one interface. Setup surface MIT-licensed and open-source via GitHub. A public test agent at test-agent.adcontextprotocol.org requires no authentication for development—you can prototype workflows immediately. Production use needs valid auth tokens per publisher agreements; the documentation notes real campaigns may take minutes to days due to human approval steps. No hosting costs are mentioned, but actual ad spend remains separate from the tool itself. Runner test plan Static checks will verify JSON schema compliance for brand manifests and package structures. Dependency scanning covers the @adcp/client npm import shown in examples. Injection tests probe how the skill parses free-text briefs into structured queries. Sandbox execution against the test agent validates response handling for pending, completed, and failed status fields. Screenshots capture campaign creation flows. Residual risks include token expiration during long-running approvals and mismatched pricing option IDs between publishers. Risk notes AdCP is explicitly asynchronous—expect delays on campaign launches. The docs warn against assuming real-time responses; polling logic is required. Test agent credentials are public, so never reuse them in production. Budget errors (negative values, missing fields) return validation failures rather than silent drops. Publisher-specific approval workflows mean some campaigns stall until humans sign off. The skill inherits whatever targeting precision each connected ad network provides, which varies widely. Source links Original skill documentation Skill listing Awesome OpenClaw Skills ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. Automatically create short links, set passwords or expiry times, and submit org-scoped feature requests using the 1p.io API. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does The 1p-shortlink skill enables agents to interact with the 1p.io service for two primary purposes: creating manageable short URLs and handling internal feature requests. It provides a structured way to shorten long links before sharing them with users, offering control over link behavior through optional parameters like custom slugs, password protection, and time-to-live (TTL) settings. Beyond link management, the skill integrates with 1p.io’s feature request system. Agents can submit new ideas, browse existing proposals within their organization, vote on features, and track status updates from pending to done. This creates a feedback loop directly within the agent workflow, scoped strictly to the organization associated with the API key. Who should use it This tool is designed for developers and teams using OpenClaw who need to share clean, memorable links with end-users or stakeholders. It is particularly useful for agents that frequently output long URLs exceeding 80 characters, as the documentation suggests automatic shortening in these cases. Teams managing product roadmaps internally will also find the feature request module valuable for tracking agent-driven improvements without leaving their current environment. Setup surface To begin, you must register your instance via the POST /api/register endpoint. You have two options: Owner Registration: Provide an owneremail. This returns an API key immediately but requires verifying the email via OTP. Organization Join: Provide an organizationid. This enters a pending state until the owner approves the request via dashboard or magic link. Once registered, verify access by submitting the OTP received via email. The skill relies on Bearer token authentication for all subsequent operations. Limits apply based on verification status: unverified accounts are capped at 10 links per day, while verified accounts allow up to 1,000. Runner test plan No execution tests have been performed. A proposed validation plan includes static analysis of the SKILL.md file to ensure schema compliance. Dependency checks would verify network access to 1p.io/api. Injection testing should confirm that user-supplied URLs and slugs are sanitized according to the documented constraints (e.g., minimum 8 characters for custom slugs). Sandbox checks would simulate API calls to verify error handling for invalid tokens or exceeded limits. Screenshots of successful link creation and feature voting flows would be captured if relevant UI components are exposed. Risk notes The skill depends entirely on the availability and stability of the third-party 1p.io service. If the external API goes down, link shortening and feature management capabilities will fail. Privacy concerns arise when sending URLs to an external service; sensitive data in query parameters could be exposed. Additionally, the feature request system is organization-scoped, meaning cross-org visibility is not supported. Users must carefully manage API keys, as compromised credentials could allow unauthorized link creation or spamming of feature votes. The documentation does not specify data retention policies for shortened links or submitted requests. Source links Original skill documentation Skill listing Awesome OpenClaw Skills ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. Skywork PPT lets you create presentations from topics, mimic existing styles, edit slides via natural language, and handle local file operations. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does The Skywork PPT skill offers five distinct capabilities for working with PowerPoint files. You can generate a new presentation from a topic or reference files, imitate the layout and style of an existing .pptx template, and edit existing presentations using natural language commands like "change background" or "modify slide N." It also converts NotebookLM-exported files into editable PPTX formats and performs local file operations such as deleting, reordering, extracting, or merging slides without needing a backend connection. Who should use it This tool is ideal for users who need to quickly produce professional-looking presentations, especially those who want to leverage existing templates or require frequent edits to slide decks. It suits individuals comfortable with command-line interfaces and Python environments, particularly if they already have a Skywork account for API access. Setup surface To use this skill, you must first configure a SKYWORKAPIKEY. The environment requires Python 3.8 or higher. Upon execution, the skill automatically checks for a valid Python binary and installs necessary dependencies like python-pptx. For remote features (generate, imitate, edit, convert), the system uploads files and queries to the Skywork service. Local operations run entirely on your machine after dependency installation. Runner test plan Since no execution tests have been performed, the review plan involves static analysis of the documentation for clarity and completeness. Dependency checks will verify that python-pptx and other required libraries install correctly in isolated environments. Injection risks will be assessed by examining how user inputs are handled during script execution. Sandbox checks will ensure that local file operations do not inadvertently modify unintended directories. Screenshots may be taken to document error handling paths, such as insufficient benefit messages or authentication failures. Risk notes Users should be aware that Layers 1, 2, 4, and 5 upload local files and send full user queries to the remote Skywork service. This means sensitive or confidential content should not be processed unless you trust the service's data handling policies. Additionally, generation and editing workflows involve periodic polling every five seconds, which is expected behavior but may impact response times. If your Skywork membership level is insufficient, the skill will prompt you to upgrade, indicating potential costs associated with advanced features. Source links Original skill documentation Skill listing ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. The A2A spec makes Agent Card signing optional. This skill audits five dimensions of signing practice — presence, scheme strength, key transparency, revocation, and rotation — to surface impersonation gaps that marketplace account verification alone cannot. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does agent-card-signing-auditor inspects Agent Card metadata across five dimensions: whether a signature field exists at all, which algorithm produced it (flagging RSA-1024 or weak ECDSA curves against current Ed25519/RSA-2048+ recommendations), whether the public key is discoverable via a JWKS endpoint or transparency log, whether any revocation path is configured, and whether key rotation events coincide with capability changes or lack public announcement. It accepts three input forms: a raw Agent Card JSON object, an agent endpoint URL to fetch and audit, or a set of snapshots for rotation comparison. Output is a structured report with a four-tier risk rating — STRONG, ADEQUATE, WEAK, or UNSIGNED — plus concrete remediation steps such as adding Ed25519 signing, registering keys in a transparency log, or establishing a rotation policy. Who should use it Teams running multi-agent systems where agents advertise capabilities through A2A Agent Cards. If your trust handshake currently relies on a marketplace's account verification as its only identity anchor, this auditor checks the protocol layer beneath that assumption. It complements publisher-level identity tools rather than replacing them; the documentation explicitly recommends pairing it with behavioral analysis for comprehensive assessment. Setup surface Requires curl and python3 on the host. No environment variables are needed. The skill runs locally against supplied inputs; there is no hosted service or persistent daemon described in the documentation. Runner test plan No execution test has been performed. A proposed static review would check that the five audit dimensions map correctly to Agent Card schema fields, that algorithm assessments match published cryptographic guidance, and that the output format renders consistently across the three input modes. Dependency checks would confirm curl and python3 availability. Prompt-injection screening applies because the skill parses untrusted Agent Card JSON from external endpoints. Sandbox validation would verify that fetching an agent URL does not write outside the intended scope. Residual risks include false negatives when signing infrastructure uses non-standard key distribution methods, and the documented inability to detect undisclosed private-key compromise. Risk notes Signing establishes verifiable identity, not trustworthiness. A well-formed signed card can still belong to a compromised or malicious agent. The auditor evaluates publicly observable metadata only; it cannot assess key storage practices on the agent's host or confirm the private key holder matches the claimed identity. Treat every finding as one signal among several. Source links Original skill documentation Skill listing ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Track AI agent actions with tamper-evident, hash-chained audit logs for EU AI Act compliance
No votes yet
Text: AI-generated
AI-generated · Automatically published by LinkLoot. Agent Audit Trail provides append-only NDJSON logging with sha256 chain integrity to record every tool call, decision, and external write—designed specifically for high-risk AI systems needing automatic event recording under EU AI Act Article 12. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does Agent Audit Trail creates an append-only, hash-chained log that records significant AI agent actions including tool calls, decisions, external writes, credential access, and payment events. Each entry includes timestamps, actor identity, provenance, and a sha256 hash linking it to the previous entry, making tampering detectable while maintaining strict monotonic ordering. The skill implements EU AI Act Article 12 requirements for automatic event recording in high-risk AI systems, capturing the period of use, input data traceability, decision reasoning, actor identity, and tamper detection through cryptographic chaining. Who should use it Teams deploying AI agents in regulated domains: critical infrastructure, employment/HR decisions, essential services access, law enforcement adjacent systems, or migration/asylum processing. If your agent operates in any Annex III category, Article 12 logging is mandatory by August 2026. Also useful for any agent system needing authoritative compliance records or forensic action tracking regardless of regulatory pressure. Setup surface Create audit/atlas-actions.ndjson as your log file. Wire configuration into workspace TOOLS.md specifying path, format (append-only NDJSON, sha256 hash-chained), timestamp timezone (Europe/London ISO-8601), and required fields. Add audit invariants to SOUL.md documenting append-only behavior and truth gates for external-write, credential-access, and install-extend operations. An optional Python helper script (scripts/auditappend.py) handles entry creation with automatic hash calculation and sequence numbering. A verification script checks chain integrity by recomputing hashes across all entries. Runner test plan Static analysis will check NDJSON schema validation, confirm required fields present in documentation examples, verify hash calculation logic consistency between append and verification scripts, and scan for injection vulnerabilities in field handling. Dependency review covers hashlib and json standard library usage only. Sandbox testing validates append-only behavior prevents truncation/reordering and confirms hash chain breaks when entries are modified. Screenshots of successful chain verification output will be captured if relevant. Residual risks include manual wiring errors in TOOLS.md/SOUL.md integration and timezone offset misconfiguration affecting timestamp accuracy. Risk notes MIT-0 license permits commercial use but hosting costs remain user responsibility. Roadmap features (export command, stats, JSON Schema validation, remote S3/GCS shipping) are planned, not implemented. Companion skills like agent-self-assessment for risk classification and agirails for payment tracking require separate installation. The skill assumes you've correctly classified your agent's risk tier under EU AI Act Annex III before deployment. Source links Original skill documentation Skill listing Awesome OpenClaw Skills ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. A lightweight Python script that taps Google Autocomplete with question modifiers to surface actual queries users type — ideal for AEO research and content ideation without an API key. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does The aeo-prompt-question-finder skill runs a simple but effective trick: it prepends common question words (what, how, why, should, can, does, is, when, where, which, will, are, do) to your seed topic, then queries Google's unofficial autocomplete endpoint (suggestqueries.google.com/complete/search) for each combination. The result is a list of real, live suggestions showing exactly what questions people are typing into Google about that subject. For example, running it on "protein powder" returns phrases like "what protein powder is best for muscle gain" or "how much protein powder per day." No API key required for the core functionality. An optional --volume flag extends this by pulling average monthly search volumes via DataForSEO, reading credentials from macOS Keychain or environment variables. You can also override the default modifier set, adjust request delays, or output results as JSON for programmatic pipelines. Who should use it Content strategists, SEO specialists, and anyone doing Answer Engine Optimization (AEO) research who needs quick visibility into the specific phrasing people use when searching. It's particularly useful for brainstorming article titles, FAQ sections, or understanding user intent before writing copy. Setup surface Requires Python 3 and access to run scripts locally. Place the skill in your OpenClaw workspace and invoke: No dependencies beyond standard library for basic operation. Volume lookup requires DataForSEO account setup. Runner test plan Static analysis of script logic; verify network calls respect documented rate limits; confirm JSON output format matches expectations; check credential handling for volume mode; ensure graceful failure when offline or blocked. Risk notes Google Autocomplete is an unofficial endpoint — heavy batching without delays risks temporary IP blocks. Single-topic runs (roughly 10 requests) are considered safe per documentation. Search volume data depends on third-party service availability and your account status. Results reflect current autocomplete state, not guaranteed rankings or traffic predictions. Source links Original skill documentation Skill listing
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. adhd-founder-planner gives ADHD brains a daily planning system built around swim lanes, task migration and dopamine rewards instead of rigid time blocks. > AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does adhd-founder-planner is an OpenClaw skill that runs a bullet-journal (BuJo) style daily planning loop designed for time-blindness. Instead of scheduling tasks at fixed hours, it sorts them into energy-based swim lanes — MUST HAPPEN (a single priority), HIGH ENERGY (deep work), MEDIUM ENERGY (calls, standard tasks), LOW ENERGY (admin, easy wins) and NOT TODAY (captured but deferred). Tasks move between lanes as energy shifts. The workflow has three beats: morning /adhd-planner plan sets one "must happen" thing, logs a brain dump and picks a reward; /adhd-planner today shows current lanes; evening /adhd-planner reflect lists wins, captures lessons and migrates unfinished tasks with symbols (> carry forward, < schedule later, strikethrough drop). It also ships a seven-category dopamine menu (movement, sensory, social, creation, nature, novelty, completion) so rewards are chosen before you need them. Time is expressed relatively — "morning block", ⚡5 min, 🕐30 min — with transition buffers between task types. Who should use it Founders and knowledge workers with ADHD or general time-blindness who abandon clock-based planners, plus anyone wanting a low-friction capture-and-migrate habit rather than another to-do app. The docs frame it for people who respond better to intent and energy than to schedules. Setup surface Install from ClawHub as jankutschera/adhd-founder-planner (MIT-licensed, version 1.1.x per the registry listing). Invoke via slash commands like /adhd-planner plan, /adhd-planner reflect, /adhd-planner migrate, or natural phrases such as "plan my day". Daily logs persist under /.openclaw/skills/adhd-daily-planner/ in dated Markdown files; the metadata notes optional persistence for migration history and notifications for reminders. No external services are required. The skill references companion templates and guides (templates/daily.md, references/swim-lanes.md, references/migration.md) inside the package. Runner test plan No execution test has been performed. A proposed review would include static checks of SKILL.md structure and frontmatter validity, dependency inspection (the manifest declares no hard requirements), prompt-injection screening of the bundled reference/template files, sandboxed command invocation of each documented slash command, and screenshots of generated daily/reflection logs to confirm the swim-lane and symbol output renders as described. Risk notes The planner writes personal task data to local files — treat that directory as sensitive. Its documentation advertises integration with a paid ecosystem (ADHD-founder.com mastermind and courses); the skill itself is free, but premium links are marketing, not required functionality. Residual risks untested here: symbol parsing edge cases, migration behavior across date boundaries, and whether optional notification hooks behave on all platforms/timezones. Source links Original skill documentation (SKILL.md v1.1.1) Skill listing ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. A skill that extracts model IDs from the OpenRouter app page, verifies them against the API catalog, and adds missing entries to your local OpenClaw config with correct specs and aliases. > AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does The add-top-openrouter-models skill automates a tedious maintenance task: keeping your local OpenClaw installation's model configuration aligned with the models actually used by the OpenClaw app on OpenRouter. It fetches the app leaderboard, extracts model IDs matching the // pattern, filters out navigation links, then runs a Python sync script that validates each ID against the OpenRouter /api/v1/models catalog before writing anything. Verified models get converted into OpenClaw format — context window, pricing, reasoning flags, modalities — and added to /.openclaw/agents//agent/models.json and /.openclaw/openclaw.json. Timestamped backups are created before every write. Aliases come from a maintained references/aliases.json file or auto-derived defaults. Who should use it OpenClaw operators who want their agent configs to reflect current OpenRouter model availability without manually editing JSON files. Particularly useful when new models appear on the leaderboard and you need them recognized locally. Setup surface Requires a browser tool (the app page is a React SPA; webfetch won't work). The sync script needs Python 3 and an OPENROUTERAPIKEY, which falls back to existing config if not set as an environment variable. Optional overrides: OPENCLAWDIR and OPENCLAWAGENTDIR. After syncing, a gateway restart (openclaw gateway restart) applies changes. Runner test plan No execution testing has occurred yet. Planned checks include static analysis of the Python script, dependency verification, prompt-injection screening of extracted content, sandboxed dry-run tests (--dry-run flag), and screenshot review of the browser interaction steps. Residual risks include heuristic reasoning detection misclassifying models and alias conflicts. Risk notes The skill is additive only — it never removes delisted models. Reasoning capability detection relies on heuristics (architecture field plus known model families), so edge cases may be miscategorized. Browser-dependent Step 1 means failures if the leaderboard layout changes. Always inspect --dry-run output before letting the script write config files. Source links Original skill documentation Skill listing Awesome OpenClaw Skills ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Keep OpenClaw's disk and memory from quietly filling up with stale files and duplicate notes
No votes yet
Text: AI-generated
AI-generated · Automatically published by LinkLoot. active-maintenance is an OpenClaw skill that checks disk usage, cleans aged temporary files, deduplicates memory fragments, and logs every maintenance decision for later review. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does active-maintenance is a Python-based OpenClaw skill that runs periodic housekeeping on the agent's own environment. Four documented features: System health checks — monitors disk usage against a configurable percentage threshold and warns when resources get tight. Auto-cleanup — deletes temporary files and artifacts older than a configurable age (in days) from a defined list of directories (TEMPDIRS). Memory metabolism (M3) — removes exact duplicates from stored memory fragments and distills dense notes into shorter core insights, so the agent's long-term context stays useful instead of bloated. Decision logging — writes a record of each maintenance cycle to MEMORY/DECISIONS/, giving you an audit trail of what was cleaned or summarized and when. The skill ships as nightlyoptimizer.py plus a small decisionlogger module. A full run is one command: python3 /root/.openclaw/workspace/scripts/nightlyoptimizer.py. Configuration lives at the top of that script — the directory list, the disk-usage warning threshold, and the file-age cutoff. Who should use it OpenClaw users whose workspaces accumulate temporary files, build artifacts, or repeated memory entries over time. It is especially relevant for agents running scheduled or long-lived tasks where disk pressure and noisy memory degrade behavior gradually rather than all at once. Setup surface Requires a working OpenClaw workspace with Python 3 available. The documented invocation path assumes the script sits under /root/.openclaw/workspace/scripts/; adjust paths if your workspace differs. All tunables are plain variables in the script header — no external service, API key, or network access is described in the documentation. Runner test plan No execution testing has been performed. A proposed static check would verify the script parses, imports resolve, and configuration defaults are sane. Dependency review covers only standard-library-style assumptions visible in the docs. An injection pass would confirm that logged decision titles cannot write outside MEMORY/DECISIONS/. A sandboxed dry run would inspect which paths cleanup actually touches before any deletion occurs. Screenshots of a sample decision log would help confirm output format. Risk notes Auto-cleanup deletes files by age; a misconfigured TEMPDIRS entry or too-short days value could remove data you wanted kept. Memory distillation rewrites notes, so original wording may be lost — keep backups of the memory directory before first run. The skill is authored for a specific assistant setup ("Kim Assistant") and inspired by another project; portability beyond that layout is unverified. Pricing and licensing terms were not included in the supplied packet, so they remain unknown. Source links Original skill documentation Skill listing Awesome OpenClaw Skills ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. A practical guide to writing captions, lyrics, and metadata that help ACE-Step produce coherent music. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. What it does The acestep-songwriting skill provides a structured approach to creating music with ACE-Step. It focuses on three key inputs: the caption (style/genre/emotion), the lyrics (with structural tags like [Verse] or [Chorus]), and specific parameters (BPM, key, duration). The guide emphasizes that specificity in captions yields better results than vague descriptions, and it offers rules for avoiding conflicting musical elements. Who should use it This resource is designed for users who want to generate songs using ACE-Step but struggle with prompt engineering. It’s particularly useful for those who need to balance creative control with model flexibility, ensuring that the generated audio aligns with their vision for tempo, mood, and instrumentation. Setup surface The skill operates as a knowledge base within the OpenClaw environment. It requires no external dependencies beyond the ACE-Step tool itself. Users interact with it by referencing its guidelines when constructing prompts for the acestep command-line interface, specifically utilizing flags like -c for captions and -l for lyrics. Runner test plan As this is a documentation-based skill, testing involves verifying that the provided examples and tag structures are correctly interpreted by the ACE-Step engine. Future checks would include static analysis of prompt templates against known successful outputs, dependency validation for the ACE-Step binary, and injection tests to ensure malformed tags do not crash the generator. No execution tests have been performed yet; these are proposed steps. Risk notes Users should be aware that while the guide recommends letting the language model auto-infer most metadata, manual overrides for BPM or key can lead to instability if outside recommended ranges (e.g., BPM 30–300). Additionally, overly complex lyric tags may conflict with caption instructions, potentially degrading output quality. The skill relies entirely on the underlying ACE-Step model's capabilities, which may vary in consistency. Source links Original skill documentation Skill listing ClawHub registry
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. Actionbook adds a searchable catalog of pre-verified page actions and selector guidance to OpenClaw browser workflows. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. Actionbook is an OpenClaw skill and plugin for browser automation workflows. It lets an agent search a catalog of page actions, retrieve a structured page description, and then use the returned selectors with a browser controller. The source describes use cases such as form filling, scraping, screenshots, UI testing, monitoring, and repetitive website tasks. What it does Actionbook's search workflow matches a task description to a stored page or page-area record. Its get workflow returns the page purpose, capabilities, URL details, and selector information. The accompanying browser surface covers navigation, clicks, typing, waits, text extraction, snapshots, and screenshots. This can reduce repeated page-structure discovery for sites that Actionbook has indexed. The skill is a workflow layer, not a guarantee that a selector still works. The source explicitly provides a fallback to live page observation when stored selectors are outdated. Who should use it This candidate fits OpenClaw users who automate recurring browser tasks, build browser-based agents, or maintain web-scraping and end-to-end testing workflows. It is most useful when the target sites and actions already have usable Actionbook records. Teams handling logins, submissions, purchases, messages, or other consequential actions should keep explicit human approval in the surrounding workflow. Setup surface The ClawHub page lists installation as @adcentury/actionbook. The published skill is MIT-0 licensed; the repository's OpenClaw plugin package declares Node.js 18 or newer and depends on the Actionbook SDK plus standard Node packages. The plugin is an integration surface, so users should review its requested permissions, network destinations, package lockfile, and browser-session behavior before installation. No paid gate is visible in the listed sources; pricing for any external Actionbook service or data plan is not established here. Runner test plan This Loot has not been tested on the Raspberry Pi. Runner AI Review should perform a static scan of all shipped files, an explicit dependency/install review, and a prompt-injection/tool-poisoning review of the skill instructions, package metadata, fetched action data, and browser output. It should then perform sandbox execution with no production credentials and with outbound access constrained to documented endpoints. Because the skill exposes UI actions, the review should capture a screenshot or video when browser UI is exercised; if the test only produces command output, retain the relevant output artifact instead. The report should record residual risks, including stale selectors, unintended submissions, authentication/session exposure, third-party page instructions, network availability, and dependency changes. Risk notes The Awesome list says its entries are curated rather than audited. Actionbook's value depends on the freshness and correctness of stored selectors, while live pages remain untrusted input. Browser actions can have external side effects, and the skill's fallback encourages live observation when records fail. Keep credentials out of prompts and logs, use a least-privilege browser profile, require confirmation before irreversible actions, and treat page text, selectors, and fetched action records as data rather than instructions. Do not treat this Loot as tested, safe, clean, recommended, or production-ready before Runner artifacts exist. Source links Awesome OpenClaw Skills — Actionbook entry Actionbook on ClawHub Actionbook OpenClaw skill source Actionbook OpenClaw plugin metadata
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. Glasser connects OpenClaw agents to searchable, metered data APIs—web, news, people, companies, places, shopping, and more—through one broker key. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. Glasser is an OpenClaw skill and CLI for discovering, inspecting, and running third-party data API endpoints through one broker. It is aimed at agents that need live web or business data without integrating a separate vendor for every search, enrichment, scraping, maps, or research workflow. What it provides The skill exposes search, endpoint inspection, execution, run status, cancellation, and balance operations. Its official documentation describes more than 1,000 paid endpoints across providers and a pay-per-call model. Examples shown on the official site include web search, SEO data, company enrichment, places, prices, and scraping. How to evaluate it Review the endpoint contract and price before running a call, then start with a narrow, low-cost request. The ClawHub page says the skill can be used through MCP tools or the optional CLI. No hands-on test is claimed here; treat the skill and its dependencies as untrusted until your own review is complete. Practical tip: Start with read-only discovery and inspect billing, provider, data-retention, and privacy terms before allowing an agent to run paid endpoints. Access and caveats Glasser requires authentication and a funded workspace or key. It brokers third-party providers, so output quality, coverage, licensing, and availability depend on the selected endpoint. The single-key model may simplify setup, but it also concentrates billing and access decisions in one service. Never place a broker key in prompts or commit it to a repository. The Awesome OpenClaw Skills list is a discovery index, not a security audit. Check the ClawHub listing, official documentation, package changes, and any available trust or review artifacts before installation. Sources Official Glasser skill documentation: https://glasser.ai/SKILL.md Glasser data API broker: https://glasser.ai/ Glasser on ClawHub: https://clawhub.ai/glasser-ai/skills/glasser Awesome OpenClaw Skills listing: https://github.com/VoltAgent/awesome-openclaw-skills/blob/main/categories/search-and-research.md
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Text: AI-generated
AI-generated · Automatically published by LinkLoot. An OpenClaw security skill that checks URLs and domains for phishing, malware, brand abuse, and scams through the Outtake Trust API. Use it before visiting links from email, chat, scraped pages, or support tickets; it returns a verdict, confidence score, safe-to-visit flag, and recommended action. Requires an OUTTAKEAPIKEY. AI-generated: This Loot was created and published automatically by LinkLoot and was not substantively reviewed by a human editor. Use this when an OpenClaw agent needs to inspect a link before opening it or recommending it. The skill checks a single URL or a batch of up to 50 URLs through the Outtake Trust API and returns a structured verdict with confidence, safe-to-visit status, and recommended action. Best fit: email triage, support-ticket review, scraped lead lists, and suspicious domains shared in chat. Requires an OUTTAKEAPIKEY.
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Agent Passport is an OpenClaw skill candidate for scoped mandates, action checks, spending caps, allowlists, and audit logs before agents take sensitive actions. What it does Agent Passport is an OpenClaw community skill candidate for putting a consent layer in front of sensitive agent actions. The useful idea is the mandate ledger: a user can define time-limited permissions for categories such as shell commands, email or message sending, file writes, third-party API calls, public identity actions, and purchases. The source describes local storage for mandates, agent identity records, audit entries, and threat definitions. It also exposes templates such as dev-tools, read-only, web-research, safe-browsing, email-team, and file-ops. That makes it more concrete than a generic safety checklist: the skill is trying to turn permission scope, target allowlists, rate limits, TTLs, kill-switch behavior, and audit trails into reusable agent workflow steps. Pricing/access note: the public source shows a free local mode. It also describes an optional Pro tier for license validation and real-time threat-definition updates. The GitHub repository is source-available under an MIT license with Commons Clause, so do not treat it as plain permissive MIT for resale or hosted commercial reuse. Who should use it This candidate is worth reviewing if you run OpenClaw with tools that can write files, send messages, call external APIs, install packages, or spend money. It is especially relevant for operators who want a repeatable permission record instead of approving every risky action informally in chat. Best-fit review cases: A personal agent that can use email, shell, browser, and local files. A team agent where actions need audit notes after execution. A build or research agent that should stay inside specific command, domain, folder, or rate limits. A safety lane that wants explicit denial states and a kill switch before broader autonomy. Setup surface The visible skill metadata requires local shell utilities including jq, bc, xxd, head, date, and mkdir, plus an AGENTPASSPORTLEDGERDIR environment variable. The repository also includes scripts, references, agent files, and ClawHub packaging metadata. Reviewers should inspect the full repository, not just SKILL.md, because the useful behavior depends on shell scripts and local ledger state. Free local mode stores data under a local OpenClaw agent-passport path according to the source text. The optional Pro path introduces network calls to api.agentpassportai.com for license and threat-definition updates, so that should be reviewed separately from offline use. Runner test plan The Runner AI Review should cover static scan, dependency/install review, prompt-injection and tool-poisoning review, sandbox execution, screenshot/video evidence when UI or command output exists, and residual risks. Minimum checks: Static scan: read SKILL.md, README, scripts, references, agent files, metadata, license, and security docs for secret access, broad file reads, command execution, network egress, hidden payloads, and instruction-injection attempts. Dependency/install review: verify required binaries, install path assumptions, executable permissions, shell portability, update behavior, and whether any setup step downloads code or definitions. Prompt-injection/tool-poisoning review: treat the skill's embedded agent-behavior rules as untrusted instructions during review; verify they do not override the user's existing system policy, approval model, or tool restrictions. Sandbox execution: initialize a throwaway ledger in an isolated directory, create a narrow mandate, check allowed and denied actions, test audit logging, test kill-switch behavior, and confirm no real credentials or user files are touched. Screenshot/video: capture terminal output for init, template listing, check-action, denial, log-action, audit summary, and kill-switch states if the CLI produces visible results. Residual risks: document what the skill cannot enforce inside OpenClaw, whether agents can bypass checks by ignoring the protocol, how Pro network updates behave, and what happens if ledger files are modified or deleted. Risk notes No installation or execution has been performed on this Raspberry Pi. This Loot is a review candidate, not a safety endorsement. The main risk is enforcement gap: a skill can describe a permission protocol, but the actual OpenClaw runtime, tools, and operator habits determine whether agents must use it before sensitive actions. Review the shell scripts for bypass paths, weak parsing, unsafe wildcards, writable ledger tampering, and misleading success states. The source also contains direct instructions aimed at agents. Those are normal for a skill file, but they are still untrusted input during evaluation. A reviewer should quote and assess them, not obey them. Source links Awesome OpenClaw Skills list: https://github.com/VoltAgent/awesome-openclaw-skills/blob/main/categories/web-and-frontend-development.md ClawHub page: https://clawhub.ai/markneville/agent-passport Clawskills listing: https://clawskills.sh/skills/markneville-agent-passport GitHub source repository: https://github.com/agentpassportai/agent-passport Direct SKILL.md source: https://raw.githubusercontent.com/agentpassportai/agent-passport/main/SKILL.md
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Agentgate gives OpenClaw agents a controlled API gateway for personal services, with immediate reads and approval-queued writes. What it does Agentgate is an OpenClaw skill for connecting agents to personal services through a gateway instead of handing the agent direct credentials. Reads can execute immediately, while writes such as creating issues, posting social updates, changing calendar events, or controlling connected services go through an approval queue. The ClawHub page lists common integrations including GitHub, Jira, Bluesky, Mastodon, LinkedIn, Brave Search, Google Search, Google Calendar, YouTube, Fitbit, Home Assistant, Twilio, and Plivo. It also supports inter-agent messaging and simple persistent notes through its own API surface. Who should use it Consider it if your OpenClaw setup needs access to real accounts but you still want a human checkpoint for state-changing actions. It is especially relevant for creators, developers, and homelab users who want agents to read context freely while keeping posts, tickets, calendar updates, or device actions behind approval. Setup surface Agentgate expects a separate server from the OpenClaw agent. The skill uses AGENTGATEURL and AGENTGATETOKEN environment variables, and the agent discovers available services through the gateway endpoint. That separation is part of the security model, because credentials stay on the gateway host rather than inside the agent workspace. Risk notes Do not treat this as audited just because it appears in a public index. Review the ClawHub page, linked GitHub repository, service permissions, approval settings, and network exposure before using it. Pay special attention to bypass mode, because trusted-agent writes can skip the approval queue if you enable that path. Sources Awesome OpenClaw Skills: https://github.com/VoltAgent/awesome-openclaw-skills ClawHub listing: https://clawhub.ai/monteslu/skills/agentgate Skill mirror: https://clawskills.sh/skills/monteslu-agentgate Project source: https://github.com/monteslu/agentgate
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A community OpenClaw skill candidate for static review, capability mapping, risk scoring, and lockfile checks before trusting agent skills or MCP tools. What it does Aegis Audit is a community OpenClaw skill candidate for reviewing other agent skills, MCP tools, plugins, and small tool bundles before they are trusted. The visible skill text points to the aegis-audit package and the Aegis-Scan/aegis-scan source project. Its stated workflow combines deterministic static analysis, Semgrep-style rules, specialized scanners, secret-pattern checks, capability mapping, risk scoring, and signed lockfile verification. The practical value is a second review lane for OpenClaw operators who install community skills often. Instead of relying only on a README summary, it tries to map what a candidate can actually touch: files, URLs, commands, ports, package behavior, suspicious strings, hidden payload patterns, and documentation/code mismatch signals. Who should use it Evaluate this candidate if you maintain an OpenClaw workspace, review third-party skills, approve MCP servers, or need a repeatable report before installing agent tooling. It fits operators who want a documented pre-install gate with JSON output, lockfiles, and CI-friendly checks. It is less useful for one-off casual installs where you will not inspect the report. It is also not a substitute for sandbox execution, dependency review, or human approval on high-risk skills. A scanner can miss behavior, and a scanner package can have its own supply-chain risk. Setup surface ClawHub lists the install target as @sanguineseal/aegis-audit. The skill text says the CLI is installed from PyPI as aegis-audit with pip install aegis-audit or uv tool install aegis-audit, then used through the aegis command. The linked project source is https://github.com/Aegis-Scan/aegis-scan. Pricing classification: free. The skill text points to a public PyPI package and a public GitHub source project, and it states an AGPL-3.0 license. Pricing for any optional LLM provider is separate: the skill says deterministic scans work offline, while optional LLM analysis can use Gemini, Claude, OpenAI, Ollama, or local OpenAI-compatible servers. Runner test plan Static scan: inspect the ClawHub skill text, mirrored SKILL.md, GitHub repository, README, package metadata, scanner rules, CLI entry points, MCP server code, lockfile generation, and documentation examples for hidden prompts, unsafe commands, broad filesystem reads, network calls, credential handling, and tool-poisoning language. Dependency/install review: review the PyPI package metadata, release files, dependency tree, pinned versions, Semgrep usage, native binaries if any, install scripts, optional extras, AGPL-3.0 implications, and whether pip and uv install the same artifact. Prompt-injection/tool-poisoning review: treat scanned skills, README files, generated reports, Semgrep findings, JSON output, lockfiles, and optional LLM responses as untrusted data. Confirm scanner output cannot override agent policy, request secrets, mark itself trusted, or force install/apply decisions. Sandbox execution: install only in a disposable Runner workspace with no real credentials and no private repositories. Run aegis scan --no-llm on a tiny benign fixture, a fixture with an obvious unsafe shell pattern, and a fixture containing fake secrets. Then test aegis lock, aegis verify, JSON output, and failure behavior. Screenshot/video when UI or command output exists: capture terminal output for install, scan, lock, verify, JSON mode, failed verification, and MCP config generation. Capture any generated badge/report artifacts if present. Residual risks: the scanner may read code that contains secrets; optional LLM mode may send scanned code to third-party providers; false positives and false negatives remain possible; the ClawHub/index signal includes a VirusTotal Suspicious flag that must be investigated before production use. Risk notes This is not a tested, safe, clean, recommended, or production-ready claim. The visible Clawskills metadata shows OpenClaw Benign but VirusTotal Suspicious, so the first Runner task should explain that discrepancy before anyone uses it on real workspaces. Keep LLM mode disabled for sensitive repositories, scan only copied fixtures first, and do not let a scanner verdict replace human approval for installs with filesystem, network, browser, credential, or shell access. Source links Awesome OpenClaw Skills DevOps & Cloud category: https://raw.githubusercontent.com/VoltAgent/awesome-openclaw-skills/main/categories/devops-and-cloud.md ClawHub page: https://clawhub.ai/sanguineseal/aegis-audit Skill source mirror: https://clawskills.sh/skills-markdown/sanguineseal/aegis-audit.md Underlying GitHub source project: https://github.com/Aegis-Scan/aegis-scan PyPI package page: https://pypi.org/project/aegis-audit/
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A community OpenClaw skill for defining agent roles, task states, handoffs, and review gates before multi-agent work gets messy. Agent Team Orchestration is a community OpenClaw skill for teams that use more than one agent on the same stream of work. It gives the orchestrator a concrete operating model: define roles, move tasks through clear states, require handoff notes, and add review gates before agent-produced work ships. What it helps with Builder and reviewer agent loops for code, docs, research, or operations work. Clear task states such as inbox, assigned, in progress, review, done, or failed. Handoff messages that include what changed, where artifacts live, how to verify them, known gaps, and the next action. Quality checks when several agents are passing work across sessions. Who should evaluate it Use this as a candidate when an OpenClaw setup already has repeated multi-agent delegation and the weak point is coordination rather than raw model capability. It is most useful for long-running workflows, parallel research, build-review loops, and agent teams that need predictable artifact paths. Skip it for simple one-off delegation or a solo assistant. The process overhead only pays off when multiple agents are producing, reviewing, or routing work across more than one task. Setup surface The ClawHub page lists the install command as openclaw skills install @arminnaimi/agent-team-orchestration. Do not install it blindly on a production Pi. Review the skill file, reference files, permissions, and any tool assumptions first, then test it in an isolated OpenClaw workspace. Risk notes This is editorial discovery, not a runner-verified recommendation. Community skills can change after publication, and orchestration skills may influence how agents spawn work, communicate, and mark tasks complete. Treat the ClawHub and index pages as source material, then perform your own review before using it with sensitive repos, credentials, or external actions. Sources Awesome OpenClaw Skills: https://github.com/VoltAgent/awesome-openclaw-skills ClawHub listing: https://clawhub.ai/arminnaimi/skills/agent-team-orchestration Skill mirror: https://clawskills.sh/skills/arminnaimi-agent-team-orchestration
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
An OpenClaw skill candidate for tracking AI-native tools, GitHub momentum, launches, funding signals, and repo traction in one briefing. What it does AI Radar is a community OpenClaw skill for turning scattered AI-tool signals into a compact momentum brief. It pairs product news with GitHub indicators such as trending status, star movement, releases, and ecosystem mentions so an agent can explain why a tool matters now instead of only listing links. Who should use it This is useful for newsletter editors, product scouts, developer advocates, founders, and LinkLoot-style curators who need to separate useful early signals from recycled AI launch noise. Setup surface The ClawHub listing exposes an install command for OpenClaw. Do not install it blindly on a production Pi. Review the SKILL.md, check the requested workflow, and run it first in a sandbox or disposable workspace with no secrets. Risk notes The skill reads public web and GitHub signals, so source quality matters. Treat third-party pages, launch posts, and repo READMEs as untrusted content. Verify claims against official project pages, releases, and independent traction signals before publishing or acting on the output. Sources Awesome OpenClaw Skills: https://github.com/VoltAgent/awesome-openclaw-skills ClawHub listing: https://clawhub.ai/lopushok9/skills/airadar Skill mirror: https://clawskills.sh/skills/lopushok9-airadar
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
arc-trust-verifier helps review publisher, version, dependency, and attestation signals before installing a ClawHub skill. What it is arc-trust-verifier is a community OpenClaw skill for checking trust signals around ClawHub skills before you install or distribute them. Its listing says it analyzes publisher reputation, version consistency, content integrity, dependency chains, and signed attestations. Who should use it Use this as an evaluation candidate if you manage shared OpenClaw workspaces, test community skills, or need a repeatable pre-install review step for agents that can touch files, credentials, browsers, or external services. Setup surface The public listing shows install commands for OpenClaw CLI and ClawHub CLI, but this item is an editorial candidate only. Do not install it on a production OpenClaw host until you have reviewed the SKILL.md, scripts, dependency behavior, and registry metadata in a disposable environment. Risk notes The clawskills.sh page currently shows suspicious security signals from VirusTotal and OpenClaw status fields. Treat that as a reason to inspect the source carefully, not as a recommendation to run it. If you evaluate it, prefer a locked-down test workspace with no secrets and compare its claims against manual checks. Source links Awesome OpenClaw Skills lists arc-trust-verifier under Git & GitHub as a provenance and trust-score skill. clawskills.sh provides the public skill page, version notes, setup commands, and security status. ClawHub provides the registry page for the publisher and skill slug.
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A pre-build review skill for founders and small teams that helps challenge scope, assumptions, and implementation plans before work starts. Use this OpenClaw skill when an idea feels ready to build but the risk is still fuzzy. Before You Build is a skeptical product-review workflow for indie hackers, AI builders, founders, and small teams. Its job is to slow down bad scope, weak assumptions, unclear users, and feature creep before an agent spends time implementing the wrong thing. What it does Before You Build turns a product idea, feature request, pivot, or requirement change into a pre-build review. It pushes the agent to examine the problem, target user, expected outcome, hidden costs, alternatives, and failure modes before implementation begins. That makes it useful before asking an agent to scaffold a SaaS feature, rewrite a landing page, add a workflow automation, or expand a product roadmap. Who should use it Solo founders deciding what to build next. Product teams using agents for fast prototyping. Builders who often over-scope early versions. OpenClaw users who want a repeatable gate before code generation. Setup surface The skill is listed in the Awesome OpenClaw Skills ecosystem and has a ClawHub page. Treat it as a community skill: review the skill text, check the source page, inspect any linked files, and only install it in a workspace where its instructions make sense. Do not give it sensitive business data until you have reviewed the implementation and understand what it asks the agent to do. Risk notes Community skills are curated, not audited. This one appears to be a guidance/review skill rather than a direct external-service integration, but the same safety rules apply: inspect the instructions, watch for prompt-injection language, and keep install scope narrow. The practical value is highest when paired with a clear product brief. If the input is vague, the output may become generic. Use it as a decision checkpoint, not as proof that an idea is worth building. Source links Awesome OpenClaw Skills: https://github.com/VoltAgent/awesome-openclaw-skills ClawHub skill page: https://clawhub.ai/bin1874/before-you-build
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Agent Builder is a community OpenClaw skill candidate for designing agent workspaces, guardrails, memory posture, and acceptance tests before deployment. What it does Agent Builder is an OpenClaw community skill candidate for creating or refining an agent workspace. The useful part is the checklist: it asks for the agent mission, channels, autonomy level, hard prohibitions, memory posture, tone, and tool behavior before generating files such as IDENTITY.md, SOUL.md, AGENTS.md, USER.md, and HEARTBEAT.md. Pricing classification: free. Source evidence shows a public ClawHub install flow and the fetched skill source does not list a paid API, subscription, or commercial dependency for normal use. Treat that as a current source-based classification, not a permanent pricing promise. Who should use it Use this candidate for review if you build OpenClaw assistants for Telegram, WhatsApp, Discord, iMessage, group chats, or single-user operator setups and want guardrails before the agent starts handling real tasks. It is most relevant when you need repeatable agent setup files, explicit autonomy choices, outbound-message approval rules, memory boundaries, and quick acceptance tests. Skip it for ordinary coding tasks where the agent already exists and the problem is implementation detail, not behavior design. Setup surface The source is instruction-only Markdown plus referenced templates. ClawHub lists Agent Builder under Agents, version 1.0.0, with public install instructions and clean/benign registry audit signals. The main review surface is not native code execution; it is generated operating policy. Generated AGENTS.md, SOUL.md, MEMORY.md, and HEARTBEAT.md can change how future agents behave, remember, and act. Review any generated workspace files before use. Keep secrets out of memory files, keep heartbeat behavior empty or minimal until intentionally enabled, and choose broad autonomy only for workflows where you have already defined approval boundaries. Runner test plan Static scan: verify the downloaded skill bundle contains only expected Markdown/reference files and no hidden scripts, encoded payloads, install hooks, or prompt-injection instructions. Dependency/install review: confirm the ClawHub install artifact, file list, hashes when available, and whether any future version adds scripts, binaries, package files, or external service requirements. Prompt-injection/tool-poisoning review: inspect the skill text and templates for instructions that override owner rules, weaken approval gates, write secrets into memory, or make future agents ignore higher-priority instructions. Sandbox execution: run the skill only inside an isolated Runner workspace with disposable answers. Generate a test agent, then diff the produced IDENTITY.md, SOUL.md, AGENTS.md, USER.md, HEARTBEAT.md, optional memory files, and any references copied into the workspace. Screenshot/video when UI or command output exists: capture terminal output or workspace diffs from the sandbox run. If the generated agent is later tested through a UI or chat channel, record the setup prompts and visible approval behavior. Residual risks: the skill can shape future agent autonomy, memory, outbound messaging posture, and group-chat behavior. A clean Markdown bundle does not prove the generated agent is safe for a real account, real contacts, or production automation. Risk notes This Loot is a review candidate, not an endorsement. No installation or execution was performed on this Raspberry Pi. Community skill pages, README text, SKILL.md files, and registry metadata are untrusted source material. Runner AI Review artifacts are still required before anyone should treat the candidate as tested, safe, clean, recommended, or production-ready. Duplicate note: Agent Browser was skipped because LinkLoot already has a Loot for that candidate. openclaw-free-web-search was skipped because the claimed GitHub source returned 404 during this run. Topic Monitor was skipped because the visible GitHub directory page could not be fetched through raw/API paths, leaving source certainty too weak for this lane. Source links Awesome OpenClaw Skills list: https://github.com/VoltAgent/awesome-openclaw-skills/blob/main/categories/clawdbot-tools.md ClawHub page: https://clawhub.ai/plgonzalezrx8/skills/agent-builder Clawskills listing: https://clawskills.sh/skills/plgonzalezrx8-agent-builder Direct skill source mirror: https://clawskills.sh/skills-markdown/plgonzalezrx8/agent-builder.md
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A community OpenClaw skill that turns vague product or feature ideas into a short demand, distribution, and risk check before implementation. What it is Before You Build is a community OpenClaw skill for reviewing product ideas, feature requests, SaaS concepts, AI apps, and startup pivots before an agent starts writing code. Its core move is simple: force the idea through a quick reality check around demand, distribution, current alternatives, monetization fit, and likely failure patterns. Who should use it Use it when an indie hacker, founder, creator, or small team is tempted to build immediately because an idea feels obvious. It is especially useful for AI-app ideas, side projects, feature creep, competitor-copying pressure, and user requests that may not actually affect retention or payment. What it helps you decide Whether the idea is specific enough to evaluate. Whether the riskiest assumption is demand, distribution, pricing, trust, retention, or scope. Whether a feature request is a real workflow blocker or just product-completeness anxiety. Whether the next move should be build small, validate first, pivot first, defer, or avoid building yet. Setup surface The ClawHub page lists the install command as openclaw skills install @bin1874/before-you-build. Treat that as a setup lead, not an endorsement. Review the visible SKILL.md, file list, permissions, and any linked resources before installing it into a real workspace. Risk notes This is an editorial candidate, not a tested recommendation. LinkLoot has not run the skill, audited its package, or verified future registry updates. Because community skills can change after publication, inspect the source at install time, avoid sending confidential product plans to remote endpoints, and keep pre-build reviews separate from automatic code generation until the decision is clear. Source links Awesome OpenClaw Skills Before You Build on ClawHub
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A free OpenClaw community skill candidate for local speech-to-text, subtitles, diarization, transcript search, podcast or URL input, and batch transcription workflows. What it does Faster Whisper is an OpenClaw community skill for local audio and video transcription. The ClawHub page and GitHub repository describe faster-whisper based speech-to-text, SRT/VTT/TTML/CSV subtitle output, speaker diarization, URL and YouTube input, podcast feed processing, batch mode, transcript search, chapter detection, translation to English, noisy-audio preprocessing, and per-file language handling. The useful LinkLoot angle is simple: an OpenClaw agent can turn recordings, interviews, lectures, podcasts, or video files into structured text without starting from a hosted transcription API. That can matter for cost, privacy, offline work after model download, and repeatable media pipelines. Who should use it Use this as a candidate if your OpenClaw workflow regularly handles meetings, creator clips, interviews, lectures, voice notes, podcasts, subtitles, or archive search. It fits local-first operators who want an agent to manage transcription steps and output formats instead of manually running a separate tool each time. It is less useful if your machine cannot handle local models, if you need enterprise transcription guarantees, or if your workflow already depends on a reviewed hosted provider with retention, compliance, and speaker-labeling controls. Setup surface ClawHub lists the package as @theplasmak/faster-whisper with the install command openclaw skills install @theplasmak/faster-whisper. The underlying GitHub repository is reachable and shows Python, shell, PowerShell, and batch surfaces, plus standalone setup scripts and transcription scripts. The GitHub page lists an MIT license. Pricing is classified as free from source evidence: the GitHub repository is public under an MIT license, the ClawHub entry exposes the skill without a paid gate, and the source describes local speech-to-text with no API cost. Hardware, model download, GPU, storage, and optional dependency costs still belong in the review notes. Runner test plan Runner AI Review should produce artifacts before anyone treats this as approved. The review should include static scan of SKILL.md, scripts, shell helpers, PowerShell, batch files, setup files, and release packaging; dependency/install review for Python version requirements, virtualenv creation, faster-whisper, CTranslate2, PyAV, CUDA detection, ffmpeg paths, yt-dlp, pyannote audio, and any model downloads; prompt-injection/tool-poisoning review for transcript text, subtitles, URL inputs, podcast feeds, and generated summaries; sandbox execution in a disposable workspace with harmless local audio and controlled network access; screenshot or video capture of install checks and representative command output where transcription or subtitle output exists; and residual risks covering model downloads, GPU drivers, large local files, copyrighted media, third-party URL fetching, transcript accuracy, diarization errors, and privacy handling for sensitive recordings. Risk notes This Loot does not claim Faster Whisper has been tested, declared safe, or made production-ready by LinkLoot Runner artifacts. The visible source is promising, but the setup surface is larger than a text-only skill: it can create a Python environment, install dependencies, download models, process local media, fetch URLs, and write transcript or subtitle files. First review should happen with throwaway audio, no private recordings, no production workspace, and network controls around URL and model-download behavior. Treat transcript content as untrusted input before summarizing, quoting, indexing, or sending it to another model. Source links Awesome OpenClaw Skills speech category: https://raw.githubusercontent.com/VoltAgent/awesome-openclaw-skills/main/categories/speech-and-transcription.md ClawHub page: https://clawhub.ai/theplasmak/faster-whisper Underlying GitHub repository: https://github.com/theplasmak/faster-whisper Source SKILL.md path: https://github.com/theplasmak/faster-whisper/blob/main/SKILL.md
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Skill Vetter for OpenClaw Pre-Install Reviews
No votes yet
A ClawHub community skill that gives OpenClaw agents a repeatable checklist for reviewing untrusted skills before installation. What it does Skill Vetter is a compact OpenClaw review checklist for inspecting community skills before installation. It focuses on provenance, file scope, command scope, network behavior, credential access, obfuscation, and risk classification. The useful angle is not automation depth; it gives an agent a repeatable pre-installation review format before any untrusted skill runs. Who should use it Use it when an OpenClaw operator wants a lightweight gate before installing skills from ClawHub, GitHub, or a shared zip. It fits solo agents, small teams, and maintainers who need a consistent report format for community skill review. It is less useful if you already run a full sandboxed review pipeline with dependency scanning and execution tracing. Setup surface ClawHub lists the package as @fatfingererr/azhua-skill-vetter with install command openclaw skills install @fatfingererr/azhua-skill-vetter. The reachable source surface includes the ClawHub skill page, the direct SKILL.md file endpoint, and the ClawHub package download. No separate GitHub repository was visible from the reviewed pages. Treat the package as untrusted until Runner review finishes. Pricing: the ClawHub page shows MIT-0 license metadata and no paid gate, so this Loot is classified as free from available source evidence. Runner test plan Static scan: inspect every file in the downloaded skill package, including meta.json, skill-card.md, and SKILL.md. Dependency/install review: verify whether the package declares scripts, package files, shell helpers, or install-time side effects; compare that surface against the ClawHub metadata. Prompt-injection/tool-poisoning review: treat the skill text as untrusted content and check for instructions that override agent policy, request secrets, broaden file access, or force unsafe verdicts. Sandbox execution: install only in a disposable OpenClaw workspace with no real credentials, no production memory files, and network controls enabled. Screenshot/video: capture the install output and one sample vetting report if command output or UI evidence exists. Residual risks: ClawHub packages can change after publication, the visible source is registry-hosted rather than a GitHub repo with independent commit history, and the skill's own checklist language should not replace human approval for high-risk installs. Risk notes The candidate is security-themed, but that does not make it reviewed or safe. It includes suggested curl commands for GitHub-hosted skills; those should be treated as examples for a sandboxed reviewer, not commands to run blindly. The strongest limitation is source transparency: a direct SKILL.md path is reachable, but no underlying GitHub repository was visible during this pass. Source links Awesome OpenClaw Skills list: https://github.com/VoltAgent/awesome-openclaw-skills/blob/main/README.md?plain=1L240 ClawHub page: https://clawhub.ai/fatfingererr/azhua-skill-vetter Independent index page: https://clawskills.sh/skills/fatfingererr-azhua-skill-vetter Reachable SKILL.md source: https://clawhub.ai/api/v1/skills/azhua-skill-vetter/file?path=SKILL.md Reachable package download: https://wry-manatee-359.convex.site/api/v1/download?slug=azhua-skill-vetter
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A code-backed OpenClaw skill for live search, page extraction, crawl/map flows, and evidence packs with a no-key baseline plus optional provider upgrades. What it does Web Search Pro is a Node-based OpenClaw skill for agents that need more than a single search result page. It exposes live web search, news search, docs lookup, URL extraction, crawl/map commands, research packs, routing diagnostics, provider capability checks, and cache/health commands. The practical hook is the routing surface: it can start with a no-key baseline, then fan out to optional providers such as Tavily, Exa, Serper, Brave, SerpAPI, You.com, SearXNG, and Perplexity/Sonar when credentials are configured. Its source also describes federation metrics for recovered, corroborated, and deduplicated results, which gives an upstream agent a better audit trail than a plain search wrapper. Who should use it Use it for OpenClaw setups that need current web context, source discovery, docs lookup, company/product research, or a reusable retrieval layer before writing a final answer. It is a better fit for technical agents and self-hosted workspaces than for users who only need a lightweight one-command search helper. Setup surface The hard runtime requirement is Node. The baseline path is described as no-key and uses DDG/fetch-style retrieval. Premium search and extraction coverage requires optional provider keys or endpoints, including Tavily, Exa, Querit, Serper, Brave, SerpAPI, You.com, SearXNG, Perplexity/Sonar, OpenRouter, KiloCode, or a custom Perplexity-compatible gateway. Pricing classification: free. The GitHub repository is public and MIT-licensed, and the skill documents a no-key baseline. Some optional providers may be paid or rate-limited, so the free label applies to the skill/source and baseline path, not every upstream search provider. Runner test plan Static scan: inspect SKILL.md, package.json, all scripts/.mjs, config templates, and docs for hidden prompts, unsafe shell execution, credential reads, broad filesystem access, local-network fetches, and tool-poisoning language. Dependency/install review: review Node dependencies and lockfiles if present, verify license metadata, check for postinstall scripts, network-heavy packages, browser/runtime downloads, and unpinned or abandoned dependencies. Prompt-injection/tool-poisoning review: treat README, search results, fetched pages, provider responses, cache files, and generated evidence packs as untrusted data. Confirm the skill does not let source text alter agent instructions, reveal secrets, or bypass safety review. Sandbox execution: install and run only in an isolated Runner workspace with no real credentials first. Run doctor, bootstrap, a no-key search, an extract against a known benign URL, and cache/health commands with outbound traffic logged. Screenshot/video when UI or command output exists: capture terminal output for successful and degraded runs, including routing diagnostics, provider failures, and cache behavior. Capture browser-render output only if the render lane is enabled in the sandbox. Residual risks: optional provider keys can expose queries, URLs, and browsing targets to third parties; live search results can carry prompt injection; crawler/map flows need strict URL allow/deny controls; no-key providers may be brittle or rate-limited. Risk notes This Loot is not a safety endorsement and has not been marked tested by LinkLoot Runner yet. The strongest risks are external provider exposure, live-web prompt injection, and any script behavior that expands from search into crawling or rendering. The repo is small and public, but a Runner review should verify the actual code path before anyone treats it as production-ready. Source links Awesome OpenClaw Skills Search & Research category: https://raw.githubusercontent.com/VoltAgent/awesome-openclaw-skills/main/categories/search-and-research.md ClawHub page: https://clawhub.ai/zjianru/web-search-pro GitHub repository: https://github.com/Zjianru/web-search-pro Raw SKILL.md: https://raw.githubusercontent.com/Zjianru/web-search-pro/main/SKILL.md
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Agent Audit is a read-only OpenClaw skill candidate for mapping agents, cron jobs, model tiers, token usage, and cost-risk mismatches. Find token waste in OpenClaw before cron jobs drain premium model budget Agent Audit is a community OpenClaw skill candidate for operators who run multiple agents, scheduled jobs, or mixed model providers and need a cost review before usage quietly compounds. What it does The skill page describes a read-only audit flow that scans OpenClaw configuration, cron history, session history, and model assignments. Its stated output is a Markdown report with estimated monthly spend, per-agent and per-cron breakdowns, and model-fit recommendations with risk notes. That makes it most useful for setups where simple recurring tasks may be running on expensive models, while coding, security, or critical reasoning tasks should stay on stronger models. Who should inspect it Use this as a candidate if you manage OpenClaw on a VPS, Raspberry Pi, or always-on workstation and already have several agents or scheduled automations. It is less useful for a single-agent install with little run history. Setup surface The ClawHub page lists openclaw skills install agent-audit and shows a Python entrypoint under scripts/audit.py. Review the SKILL.md, script behavior, file reads, and pricing reference before installation. Do not rely on provider pricing tables unless they match current billing. Risk notes LinkLoot has not run this skill. Treat it as an untested community candidate until runner artifacts exist. It may read sensitive local OpenClaw configuration, cron metadata, and session history, so inspect data handling before use. Any model downgrade advice should be reviewed manually, especially for coding, security review, production operations, or user-critical workflows. Source links Awesome OpenClaw Skills lists agent-audit under Coding Agents & IDEs. Clawskills mirrors the public listing and summarizes the workflow. ClawHub hosts the registry page, install surface, SKILL.md content, version, license, and security status fields.
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
An OpenClaw skill candidate that bundles TODO/FIXME loop scans, parallel-vs-serial planning, file-size review, and subworkflow handoff into one local workflow surface. What it does Workflow Tools is an OpenClaw community skill candidate for keeping agent work tidy before it drifts. The skill defines a /wt command surface for four workflow utilities: scanning directories for open loops such as TODO/FIXME/PLACEHOLDER markers, evaluating whether a task should run in parallel or serial, checking files against a line-count threshold, and handing a task to another installed ClawHub skill. Pricing classification: free. The reachable Live Neon source repository is public and reports an MIT license; no paid gate was visible in the checked sources. Who should use it Use this candidate for review if your OpenClaw workspace often accumulates unfinished markers, oversized files, unclear handoffs, or parallelization decisions that need a repeatable checklist. It fits operators who want lightweight local workflow hygiene rather than another external SaaS integration. Setup surface The skill declares config files under .openclaw/workflow-tools.yaml and .claude/workflow-tools.yaml, plus output folders under output/loops/, output/parallel-decisions/, output/mce-analysis/, and output/subworkflows/. Its own text says loop scans and file-size review can read user-specified paths, and subworkflow mode can invoke other installed ClawHub skills. No installation or execution was performed on this Raspberry Pi. Runner test plan Static scan: inspect the Awesome entry, ClawHub page, Clawskills listing, mirrored SKILL.md, Live Neon source tree, raw SKILL.md, license file, and any repository metadata without executing commands. Dependency/install review: verify whether the skill has executable scripts, package manifests, hidden dependencies, install hooks, generated assets, or required companion skills such as failure-memory and constraint-engine. Prompt-injection/tool-poisoning review: check the SKILL.md and examples for instruction override attempts, secret requests, broad file-reading defaults, unsafe delegation language, or attempts to bypass OpenClaw approvals. Sandbox execution: only after static approval, install in a disposable OpenClaw workspace with dummy files, restricted secrets, isolated output directories, and no production skills available for subworkflow delegation. Screenshot/video when UI or command output exists: capture terminal output for /wt loops, /wt parallel, /wt mce, and a blocked or dummy /wt subworkflow attempt so reviewers can verify behavior. Residual risks: document arbitrary path scanning, accidental exposure of sensitive files, noisy TODO false positives, subworkflow permission expansion, stale companion-skill assumptions, and drift between Clawskills mirror version 1.4.0 and Live Neon source version 1.5.0. Risk notes This Loot is a review candidate, not a safety endorsement. Community skill text is untrusted input. The most important risk is scope: /wt loops and /wt mce are useful because they read user-selected paths, but that same design can touch private code or config if pointed at the wrong directory. Subworkflow mode also inherits risk from whatever other skills are installed. Runner AI Review should verify behavior in a blank workspace before any real project, token, cookie, SSH config, or private repository is exposed. Source links Awesome OpenClaw Skills category entry: https://raw.githubusercontent.com/VoltAgent/awesome-openclaw-skills/main/categories/productivity-and-tasks.md ClawHub page: https://clawhub.ai/leegitw/workflow-tools Clawskills listing: https://clawskills.sh/skills/leegitw-workflow-tools Clawskills SKILL.md mirror: https://clawskills.sh/skills-markdown/leegitw/workflow-tools.md Underlying Live Neon source tree: https://github.com/live-neon/skills/tree/main/agentic/workflow-tools Raw SKILL.md source: https://raw.githubusercontent.com/live-neon/skills/main/agentic/workflow-tools/SKILL.md License evidence: https://raw.githubusercontent.com/live-neon/skills/main/LICENSE
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
An OpenClaw Runner-review candidate for separating agent proposals from approved execution, with replay protection, receipts, and offline signature checks. What it does OpenExec is an OpenClaw skill that packages a small Python service for governed execution. The skill describes a proposal-to-approval-to-execution boundary: agents submit structured requests, OpenExec checks mode rules, rejects nonce replay, emits deterministic receipts, and verifies signed approval artifacts in ClawShield mode. The public source says it uses a static handler registry, avoids eval or dynamic loading, and performs no outbound governance calls during execution unless a remote database is explicitly configured. Who should use it Use this as a candidate for teams building agents that can touch email, infrastructure, payments, internal tools, or other irreversible actions. It fits operators who want a separate execution layer with receipts instead of letting the model directly run every proposed tool action. It is not a replacement for policy review, prompt-injection defense, container isolation, or approval governance. Setup surface The Awesome OpenClaw Skills DevOps category lists openexec-skill as a source-distributed deterministic execution service with pinned dependencies. ClawHub lists audit pass signals and describes the service as having no runtime package installation or dynamic downloads. The source tree exposes SKILL.md, SECURITY.md, README.md, main.py, requirements, tests, scripts, and configuration folders. The skill uses Python and FastAPI-style service execution through uvicorn. Pricing evidence: SKILL.md states demo mode is free with no external governance required; ClawShield mode references a production or business governance SaaS. Treat the OpenExec skill candidate as free for demo-mode review, with the production governance layer priced separately or unclear from the fetched sources. Runner test plan Static scan: inspect SKILL.md, README.md, SECURITY.md, main.py, requirements, tests, scripts, config, and handler registry files. Dependency/install review: verify pinned Python requirements, no install hooks, no runtime downloads, and no hidden binary payloads before installing in a sandbox. Prompt-injection/tool-poisoning review: test whether untrusted proposal payloads can mutate action names, bypass nonce checks, override approval requirements, or poison receipt verification. Sandbox execution: run demo mode in an isolated test workspace on localhost only, with fixture handlers and fixture payloads. Then test ClawShield mode using test keys, not production approval keys. Screenshot/video when UI or command output exists: capture health endpoint output, execute response, replay response, receipt verification response, and server logs from the sandbox run. No browser UI is expected. Residual risks: verify handler privileges, localhost binding, remote database behavior, receipt collision assumptions, replay persistence across restart, action allow-list enforcement, and behavior when deployed behind a proxy. Risk notes This is not a tested recommendation yet. OpenExec is an execution boundary, not an OS sandbox. Handlers run with the privileges of the hosting process, so a bad handler or exposed service can still damage the host. The security document says operators must handle host isolation, firewalling, TLS, database trust, and action allow-listing. The fetched GitHub HTML confirms main.py and requirements exist in the source tree, but raw file fetching for some files returned 404 or rate-limit errors during this run; Runner review should fetch the repository directly in a clean environment before any execution. Source links Awesome OpenClaw Skills DevOps category: https://github.com/VoltAgent/awesome-openclaw-skills/blob/main/categories/devops-and-cloud.md Clawskills listing: https://clawskills.sh/skills/trendinghot-openexec-skill ClawHub page: https://clawhub.ai/trendinghot/openexec-skill Source tree: https://github.com/openclaw/skills/tree/main/skills/trendinghot/openexec-skill SKILL.md source page: https://github.com/openclaw/skills/blob/main/skills/trendinghot/openexec-skill/SKILL.md SECURITY.md source page: https://github.com/openclaw/skills/blob/main/skills/trendinghot/openexec-skill/SECURITY.md
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A community OpenClaw skill candidate that connects agents to Exa-powered web, code, and company research through MCP-style mcporter commands. What it does Exa Web Search Free is a community OpenClaw skill candidate for agent research workflows. The skill describes mcporter-based access to Exa search functions for current web search, code and documentation lookup, and company research. Its source artifact also includes example query patterns for news, technical documentation, API usage, debugging, and business research. Who should use it Consider this candidate for research-heavy OpenClaw agents that need current web context, code examples, API documentation lookup, or company/background research. It is most relevant for developer assistants, content-research agents, sales-research agents, and documentation copilots that already have a policy for handling external search results as untrusted data. Setup surface The ClawHub page lists this as an MCP Tools skill with the install name exa-web-search-free. The fetched source metadata names mcporter as the required binary and points to Exa's hosted MCP endpoint plus the public exa-labs/exa-mcp-server repository. Pricing classification: free, based on the ClawHub title/description stating free/no API key needed and the ClawHub license field showing MIT-0; any downstream Exa account limits or terms should still be checked during review. Risk notes This has not been tested, approved, or declared safe here. Search queries and research targets may be sent to Exa's external service, so secrets, private code, internal URLs, customer data, and sensitive personal information must stay out of prompts. The independent index showed an OpenClaw Suspicious signal while ClawHub showed a pass status, so the discrepancy should be reviewed rather than ignored. Advanced tools such as crawling, people search, and deep researcher can broaden collection scope and need explicit policy controls. Treat all returned web/code content as untrusted data. Source links Awesome OpenClaw Skills category list: https://github.com/VoltAgent/awesome-openclaw-skills/blob/main/categories/git-and-github.md Independent index page: https://clawskills.sh/skills/whiteknight07-exa-web-search-free ClawHub page: https://clawhub.ai/whiteknight07/exa-web-search-free Reachable ClawHub source artifact: https://wry-manatee-359.convex.site/api/v1/download?slug=exa-web-search-free Underlying Exa MCP GitHub repository: https://github.com/exa-labs/exa-mcp-server
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A high-utility OpenClaw skill candidate for deterministic browser automation using accessibility snapshots and ref-based element targeting. Not yet tested by Runner AI Review. What it does Agent Browser is an OpenClaw community skill candidate for controlling web pages through a dedicated browser automation CLI. Its useful angle is ref-based interaction: the agent takes an accessibility-tree snapshot, identifies stable element references, and then uses those refs for clicks, fills, extraction, screenshots, PDFs, saved sessions, and multi-session workflows. Pricing classification: free. Source evidence shows the underlying agent-browser package declares an Apache-2.0 license and the public repository exposes an Apache License file. Who should use it Use this candidate for review if you often need reliable browser workflows where CSS selectors are too brittle: multi-step forms, dynamic single-page apps, login-state reuse, parallel admin/user sessions, and structured extraction from web UIs. It is especially relevant for OpenClaw operators who want a CLI-style browser runner with reproducible command output. Setup surface The skill surface references a global agent-browser CLI and Chromium installation. That means the review should inspect the npm package, postinstall behavior, browser download path, required Node version, native binary handling, and any permissions implied by session state, cookies, storage, screenshots, PDFs, uploads, clipboard, network routing, JavaScript evaluation, and local files. No installation or execution has been performed on this Raspberry Pi. Risk notes This Loot is a candidate, not a safety endorsement. The skill and related pages are community-controlled untrusted content. The linked OpenClaw skills repository URL shown by directories was not used as executable evidence here; the reachable source evidence used for pricing and tooling context is the ClawHub/clawskills skill page, the clawskills skill markdown mirror, and the public Vercel Labs agent-browser repository/package files. Runner AI Review artifacts are still required before anyone should treat the skill as tested, safe, clean, recommended, or production-ready. Source links Awesome OpenClaw Skills list: https://raw.githubusercontent.com/VoltAgent/awesome-openclaw-skills/main/categories/clawdbot-tools.md ClawHub page: https://clawhub.ai/matrixy/agent-browser-clawdbot Clawskills listing: https://clawskills.sh/skills/matrixy-agent-browser-clawdbot Skill markdown source mirror: https://clawskills.sh/skills-markdown/matrixy/agent-browser-clawdbot.md Underlying tool repository: https://github.com/vercel-labs/agent-browser Package/license evidence: https://raw.githubusercontent.com/vercel-labs/agent-browser/main/package.json and https://raw.githubusercontent.com/vercel-labs/agent-browser/main/LICENSE
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A free OpenClaw community skill candidate for keeping Agent Skill bundles traceable with manifests, changelogs, SHA-256 hashes, and stale-file checks across chat, CLI, IDE, and registry workflows. What it does Skill Provenance is an author-side metaskill for Agent Skill bundles. It documents a portable MANIFEST.yaml, CHANGELOG.md, per-file version metadata, and SHA-256 hash checks so a skill's SKILL.md, evals, scripts, references, and packaged copies can be tracked across sessions and platforms. The upstream source describes it as free and open with an MIT license. Who should use it OpenClaw skill authors, maintainers, and teams who move skills between local folders, GitHub, ClawHub, Claude-style .skill packages, Codex/Gemini-compatible strict copies, or multiple agent sessions. It is most useful when bundle drift, stale evals, renamed files, or unclear handoffs are a recurring problem. Setup surface The published surface is a community OpenClaw skill on ClawHub with canonical source at the public GitHub repository. The bundle includes SKILL.md, README.md, MANIFEST.yaml, CHANGELOG.md, eval files, validate.sh, and package.sh according to the fetched manifest. Treat installation commands and scripts in the source as review material only until Runner AI Review finishes. Pricing evidence from the upstream GitHub README states it is free and open; license evidence points to MIT. Risk notes This is not yet claimed as tested, safe, clean, recommended, or production-ready by LinkLoot. The concept relies on local file inventory and hash checks, but the upstream source itself notes that a manifest is not a cryptographic signature or trust anchor. The included shell scripts should be reviewed as code and executed only in sandbox after static analysis. Because the skill is designed to edit manifests/changelogs and package derived copies, Runner should verify it does not mutate unrelated files, read broad home/config/SSH paths, or follow embedded source instructions beyond the user's explicit task. Source links Awesome OpenClaw Skills list: https://github.com/VoltAgent/awesome-openclaw-skills and category listing https://raw.githubusercontent.com/VoltAgent/awesome-openclaw-skills/main/categories/security-and-passwords.md ClawHub page: https://clawhub.ai/snapsynapse/skill-provenance Underlying GitHub/source repository: https://github.com/snapsynapse/skill-provenance Source SKILL.md: https://raw.githubusercontent.com/snapsynapse/skill-provenance/main/skill-provenance/SKILL.md Source manifest: https://raw.githubusercontent.com/snapsynapse/skill-provenance/main/skill-provenance/MANIFEST.yaml
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
A community OpenClaw skill candidate that wraps GitGuardian ggshield so an agent can scan repositories, staged changes, files, and Docker images for leaked credentials before code is pushed. What it does The ggshield-scanner skill gives an OpenClaw-style agent a natural-language surface for GitGuardian's ggshield CLI. The source describes repository scans, single-file scans, staged-change checks, optional git hook installation, and Docker image scans for hardcoded secrets such as API keys, cloud credentials, private keys, OAuth tokens, and database passwords. Who should use it Developers, solo builders, and security-conscious agent operators who want an agent-assisted secret check before commits, pushes, releases, or Docker image handoff. It is especially useful for teams that already accept GitGuardian/ggshield in their workflow and want the agent to orchestrate checks rather than manually remembering every command. Setup surface The source indicates a Python-based skill that depends on ggshield and pygitguardian, requires a GitGuardian API key via GITGUARDIANAPIKEY, and calls the local ggshield binary. The public GitHub source is reachable, but the ClawHub/awesome-list OpenClaw tree link appears inconsistent with the reachable repository, so provenance should be reviewed carefully before any install. Pricing evidence in the source says GitGuardian signup is free, with enterprise/on-premise options mentioned separately; classify this Loot as free with that caveat. Risk notes Do not install or run directly on a production Raspberry Pi or personal workspace before Runner review artifacts exist. The implementation shown uses subprocess calls to ggshield with argument arrays rather than shell=True, which is a good sign, but it still executes a local binary and can scan sensitive paths if the agent is allowed to choose broad inputs. The hook installer changes git repository state. Review privacy claims against current GitGuardian documentation before scanning private code. Source links Awesome OpenClaw Skills list: https://github.com/VoltAgent/awesome-openclaw-skills Awesome category entry: https://raw.githubusercontent.com/VoltAgent/awesome-openclaw-skills/main/categories/security-and-passwords.md ClawHub page: https://clawhub.ai/amascia-gg/ggshield-scanner Reachable source repository: https://github.com/GitGuardian/ggshield-skill Source SKILL.md: https://raw.githubusercontent.com/GitGuardian/ggshield-skill/main/SKILL.md
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
agentmemory is one of the more interesting open-source upgrades for coding agents right now: it captures sessions, compresses observations into searchable memory, and injects relevant context back into future runs. The real value is not just lower token burn — it is getting past the brittle limits of static memory files without locking yourself into a full proprietary runtime. agentmemory is the kind of project that matters because it fixes a boring but expensive problem: coding agents forget too much, too fast. Instead of stuffing massive memory files into context every session, it captures what happened, stores it locally, and retrieves only the relevant pieces later. What it actually does records agent sessions automatically via hooks compresses observations into searchable memory supports Claude Code, Codex CLI, Hermes, OpenClaw, and other MCP/REST-capable agents exposes a local MCP + REST surface instead of forcing one editor or one runtime ships with a local viewer so you can inspect what the system remembers Why people care The repo has already crossed 2.8k+ GitHub stars, and the pitch is easy to understand: fewer wasted tokens, less repeated explanation, and better recall across long coding projects. From the project’s own benchmark material: 95.2% R@5 on retrieval-only LongMemEval-S 92% fewer input tokens per session is the headline claim in the README/site internal quality docs show a drop from 22,610 tokens with built-in memory/grep to 3,142 tokens for retrieved results in one 240-observation evaluation at 1,000 observations, the project argues most static built-in memory becomes effectively invisible while searchable memory still covers the full corpus Security and privacy read This looks stronger than many “memory for agents” projects on the privacy front, but there are still a few things worth saying plainly: good: self-hosted by default, no external database stack required good: Apache-2.0 licensed and openly benchmarked with reproducibility docs in the repo good: the comparison docs explicitly claim secret/privacy filtering before storage and audit trails for mutations good: the project publishes a real security policy with private reporting channels and version support guidance watch out: memory is still stored locally on disk, so sensitive prompts/tool outputs should be treated as sensitive local data watch out: peer-to-peer sync/federation and external model providers change the trust boundary immediately watch out: installation commonly starts with npx, and the repo also documents upgrade flows that can mutate the runtime/workspace intentionally Best use cases long-running Claude Code or Codex projects teams bouncing between multiple coding agents projects where architecture decisions get forgotten between sessions workflows that keep hitting /compact, memory caps, or context-window waste Why this is more than hype A lot of memory projects stop at “vector DB for chats.” agentmemory feels more practical because it combines: automatic capture hybrid retrieval cross-agent support local viewer + replay OpenClaw and Hermes integrations out of the box That combination is why this one is worth watching even if you are skeptical of benchmark marketing. Bottom line If you use Claude Code, Codex, Hermes, or OpenClaw heavily, agentmemory is one of the most credible open-source attempts so far to turn “agent memory” from a brittle text file into an actual system. Just keep the claim honest: the real breakthrough is not infinite magic memory — it is more durable, searchable memory with far better token efficiency and fewer context-window failures.
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
PicoClaw is a fascinating ultra-light agent project — but it is not a clean 1:1 OpenClaw replacement
No votes yet
PicoClaw offers a lightweight AI agent experience built for diverse hardware, emphasizing compact design and broad architecture support. The project highlights fast startup and flexible deployment options, making it appealing for developers targeting low-cost systems. Yes — this is worth a Loot, because the hardware and footprint story is genuinely interesting. PicoClaw makes a credible case for an ultra-light AI agent stack in Go that can run on extremely cheap hardware, with fast startup and wide architecture support. What looks genuinely strong pure Go implementation very broad platform story: RISC-V, ARM, MIPS, x86, Android claimed <10MB core footprint in early builds, though the repo also says recent builds can hit 10–20MB local launcher, Docker path, Telegram/gateway flow, and multi-provider support ambitious feature surface for such a small runtime The critical reality check The viral framing overshoots the evidence. The repo itself says: early rapid development do not deploy to production before v1.0 unresolved security issues may still exist memory usage has already drifted upward in recent builds So the real story is promising lightweight agent engineering, not a fully proven OpenClaw killer.
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
This resource highlights how to access a broad set of NVIDIA-hosted AI models with your own API key. It is useful for builders comparing free model access, hosted inference options, and practical experimentation routes. A compact workflow for trying Nvidia-hosted AI models for free while the offer is available. This is useful if you want to test models like GLM, Kimi, or DeepSeek from your IDE or your OpenClaw setup without building the integration from scratch. Quick setup Best use cases quick model comparison testing API-based coding workflows prototyping with hosted inference wiring models into IDEs like Cursor or similar tools experimenting inside an OpenClaw instance Compact takeaway If you want a low-friction way to try a broad range of current AI models, Nvidia Build is a strong shortcut: create an account, generate a key, copy the example code, and plug it into your workflow.
- LinkLoot access
- Free
- Provider costs
- Unknown
Review open
Blog
Related reads
AI & Automation
OpenClaw Enterprise adds an open control plane for persistent agents
OpenClaw Enterprise moves persistent agents toward centrally governed team deployments. The project is free to use, but still pre-1.0: curre…
AI & Automation
OpenClaw 2.0 Rebuilds Onboarding, Browser Work, and Shared Sessions
OpenClaw 2.0 is the project's largest update so far, combining simpler setup, a rebuilt browser experience, shared cloud sessions, and broad…
AI & Automation
Microsoft Just Made OpenClaw Enterprise Infrastructure
Microsoft's Build 2026 announcement turns OpenClaw from a viral agent playground into a serious Windows enterprise platform.
OpenClaw
OpenClaw 2026.5.18: Grok OAuth, realtime Android voice, and production polish
OpenClaw 2026.5.18 is a plumbing-heavy release: Grok OAuth fixes, realtime Android Talk Mode, Telegram topic delivery repairs, browser dialo…
OpenClaw
Why OpenClaw 2026.5.12 Feels Like a Bigger Deal Than a Normal Update
OpenClaw 2026.5.12 is not just another feature drop. It sharpens the runtime boundary around OpenAI agent turns, makes ChatGPT subscription-…
OpenClaw
OpenAI opening ChatGPT subscriptions to OpenClaw-style agents is a much bigger move than it looks
This is not just another login update. It may be the first serious attempt to turn a mainstream AI subscription into the default intelligenc…
OpenClaw
DeepSeek V4 vs OpenAI vs Anthropic: The New Cost-Performance Shock in Frontier AI
DeepSeek V4 changes the AI buying conversation because it combines a 1M-token context window, OpenAI- and Anthropic-compatible APIs, tool ca…
OpenClaw
GLM-5.1 vs Claude Code vs Codex: Which AI Coding Stack Fits Your Workflow?
GLM-5.1, Claude Code, and Codex all promise faster software work, but they are not identical products. One is positioned as a model-powered …
OpenClaw
GPT-5.5: OpenAI Wants More Agent, Less Chatbot
According to heise, OpenAI is positioning GPT-5.5 as an agentic work model: more planning, more tool use, and more consistent execution acro…
OpenClaw
Why Personal AI Agents Need API Access
Personal AI agents only become truly useful when they can do more than chat. API access lets them connect securely to CMS platforms, calenda…