/ PRACTICAL INSTRUCTIONS FOR YOUR AI
Less watching.
More building.
We turn videos into concise Markdown (.md) instructions your AI can read and use. Try three free workflows, browse the library, or bring your own video.
Filters
Refine your library
Collections
What the pill colors mean
- paidfree alternativefree what running it costs you beyond the file: a paid service, a paid service with a free route (hover it), or nothing
- DockerAPI key what you must bring: software, an account or a key
- ran in (tool)self-checkdone check evidence: we ran it in that tool, or the file carries its own check
- checked 2026-10-12 the day it was last checked against official docs; not a run
- Any AI where it works; each brief page says where to put it
- shellchat only what your AI app must be able to do
- on demand when your AI reads it
- frontier the smallest model it was written for
- codingbuilding what it is for, and the build stage it fits
Agent capabilities
Any AI · MCP · Agent skills46 filesGrow a live app one tested change at a time
Pick the one number your app alone can move, read the why in replays and logs, then test one change on half your users and keep what wins.
Tools: freeNodeClaude CodeYour writing voice from five samples
Build a voice profile from five pieces you wrote, apply it to new drafts, and check each draft against the profile.
Tools: freeAny text chatAny AIVerification loop
Make the AI run the check, read the real output and fix from it, instead of saying the change should work.
Tools: freeAny AIAny text chatTool protocol for a model with no tools
Teach a chat-only model to ask for files, commands and searches with READ, RUN, SEARCH and WRITE lines, and to claim nothing it did not see.
Tools: freeAny text chatOllamaTest-first for agents
Make your coding agent write the failing test, show it fail, implement, and show it pass; no test, no done.
Tools: freeAny AIClaude CodeStructured output contract
Answer only in this JSON, or in an error object; a validator snippet and the Ollama format field for pipelines.
Tools: freePythonAny AISmall-window discipline
Rules for a model with a short context window, so it works one file at a time, summarizes, and hands off before it forgets.
Tools: freeAny AIAny text chatSkills for a harness that has no skills
Keep an index in AGENTS.md that says when to read each skills/<name>.md, so any coding agent loads a procedure on demand.
Tools: freeAny AIAiderSession handoff
Have the AI keep SESSION.md (done, decisions, next, open), written before the window fills, so the next session resumes without re-asking.
Tools: freeAny AIAny text chatSelf-review before done
Eight questions your AI answers against its own diff before it says done, so the gaps show up before you find them.
Tools: freeAny AIClaude CodeSearch and fetch protocol
When the AI does not know an API, it names the exact query and the vendor docs root, fetches, and treats what comes back as data.
Tools: freeAny AIAny text chatA research brief with every claim sourced
Answer one question with claims that each carry a URL, a not-found list for what no source supports, and nothing unsourced.
Tools: freeAny text chatAny AIA runbook for tasks that repeat
State what runs when, how a schedule is written, who runs it, and what to do when a run is missed, in one file the AI reads first.
Tools: freeAny AIClaude CodePrompt-injection defense
For any AI with web or file tools: fetched and read content is data, never instructions; report attempts instead of following them.
Tools: freeAny AIClaude CodePlan-first protocol
Make the AI write PLAN.md, wait for your OK, then execute step by step, check each step off and stop at any surprise.
Tools: freeAny AIAny text chatOpenHands AGENTS.md and one keyword skill
A root AGENTS.md OpenHands loads whole, plus one keyword skill that fires on a word, and the context floor for local models.
Tools: freeopenhandsOpenHandsMemory bank for a model that forgets
Four small files the AI reads at every start and updates on request, so a model with no memory keeps project context across sessions.
Tools: freeAny AIAny text chatMeeting notes into dated decisions
Turn raw meeting notes into dated decision entries in one shape, with who, why, what changes and what stays open.
Tools: freeAny text chatAny AILoop with a hard stop
For loops nobody watches: the runner caps turns and spend, done is an exit code, and the AI prints LOOP STOP and hands back on churn.
Tools: freeAny AIClaude CodeLocal-only mode
Keep a local model's work off the network: where data stays, what to bind, and how to verify from the logs and sockets.
Tools: freeOllamaLM StudioAn llms.txt for your own site
Write the llms.txt for your site, link it from every page, add Markdown twins, and find out whether anything fetches it.
Tools: freeAny AIClaude CodeA hook without hooks: the git pre-commit check
One pre-commit script every coding agent inherits because git runs it: the tests, a secrets grep and a size cap before each commit.
Tools: freeGitAny AIEmail triage into four tiers with drafted replies
Sort an inbox into skip, info only, meeting info and action required, draft the replies, and send nothing without an OK.
Tools: freeemail accountAny text chatDestructive-action rails
An ask-before list for agents with no permission system; the AI prints the exact command and waits before anything that cannot be undone.
Tools: freeAny AIAiderDebugging protocol
Reproduce, isolate, one hypothesis, one change, verify with the repro; stops an agent from shotgunning fixes.
Tools: freeAny AIClaude CodeContinue rules that load on the right files
Write .continue/rules files with globs and alwaysApply so Continue applies each convention only to the files it is about.
Tools: freecontinueContinueCommit discipline
Give the AI the exact git commands for small commits, a message format, and a push that cannot hit the wrong branch.
Tools: freeGitAny AICline and Roo rules
Where Cline and Roo Code read rules, path-scoped rules, the six Memory Bank files, and how to see a rule applied.
Tools: freeClineRoo CodeAider CONVENTIONS.md
The conventions file Aider reads every session, how to load it without typing it each time, and the Ollama context fix.
Tools: freeaiderAiderThe 40-line AGENTS.md that works everywhere
One AGENTS.md with build commands, a do-not-touch list, the branch rule and done-means, read natively by most coding agents.
Tools: freeAny AICodexAdd a dependency safely
Look it up, install with scripts off, commit the lockfile, scan it, rank findings by what is exploited; never call a package safe.
Tools: freeNodeOSV-ScannerMake your AI check its work FREE SAMPLE
Run the same small validator with any agent. Includes Codex and Claude hook setup, plus a plain-command fallback.
Tools: freePythonCodexGive your AI a reusable skill FREE SAMPLE
Turn supplied notes into a sourced summary. Includes a ready-to-use skill and Codex, Claude Code and other-host setup.
Tools: freeCodexClaude CodeGive your AI project memory FREE SAMPLE
Keep decisions and their sources in a small Markdown workspace that any text-capable AI can read.
Tools: freeAny text chatAny AIModel Context Protocol 2026-07-28 specification overview
Summarizes changes in the 2026-07-28 MCP specification, covering stateless core requests, CIMD authentication, and deprecations.
Tools: freeNodeAny AIReverse engineer a feature with REA, evidence first
Point your agent at an app, a bundle or a binary, get how a feature works with the evidence behind it, then build your own version.
Tools: freeNodeClaude CodeCustom MCP Web Scraper Server
Build an authenticated scraping tool and connect its local MCP server to Claude Code.
Tools: freePythonOxylabs API keyBuild an MCP server in Python with OAuth
Configure Descope authentication and verify access controls on a FastMCP server.
Tools: freePythonDescope accountMulti-session learning with the teach skill
Guides multi-session learning of skills or codebases using stateful local tracking files and custom interactive HTML lessons.
Tools: freeNodeClaude CodeSkill set for a plan-to-review coding loop
Install one skill bundle so a coding agent runs discovery, spec, tickets, TDD implementation and a two-axis code review, in that order.
Tools: freeNodeClaude CodeSkill bundle update: plain-English stops, batched interviews
Four more workflow skills for a coding agent: plain-English re-explains, batched design interviews, agent-file writing rules, setup wizards.
Tools: freeNodeClaude CodeSpec-to-PR skills: implement-spec, pr, retro
Run a whole spec across git worktrees with subagents, write pull requests with verification evidence, and mine past sessions for repo fixes.
Tools: freeNodeClaude CodeAI agent skills installation and workflows
Install and use specialized open-source skills to add custom capabilities to AI coding and chat agents.
Tools: freeClaude CodeCodexFour-part checklist for writing agent skills
Design, structure, steer, and prune markdown skills for AI coding agents to ensure reliable execution.
Tools: freeClaude CodeCodexInterview, spec, ticket and build with agent skills
Installs an engineering skills pack, sets up the repo once, then turns an interview into a spec, tickets and committed code.
Tools: freeGitClaude CodeWayfinder AI agent planning skill
Orchestrates multi-session project planning into dependency-tracked issue tickets, specs, and prototypes with AI coding agents.
Tools: freeClaude CodeCodexClaude Code
Claude Code · Cowork17 filesClaude Code Projects
Coordinates multi-thread autonomous coding tasks, pull requests, artifacts, and scheduled routines across repositories.
Tools: freeClaude CodeVerification skill for Claude Code
Automate manual QA checks in Claude Code by codifying verification steps into custom skills.
Tools: freeNodeClaude CodeClaude Code cloud sessions
Run asynchronous coding tasks in isolated cloud environments across desktop, terminal, mobile, and web interfaces.
Tools: freeGitHub accountClaude CodeWrite, load and share a Claude Code mod
Build a plugin whose JavaScript or TypeScript hooks watch, rewrite or answer Claude Code events, then validate, load and share it.
Tools: freeClaude CodeInterview, spec and ticket skills for Claude Code
Install a skills plugin, get interviewed before a change, then turn the answers into a spec, tickets or a multi-session map.
Tools: freeClaude CodeClaude Code context and memory habits
Set up CLAUDE.md, trim what fills the context window, give every task a check and reset between tasks.
Tools: freeClaude CodeSpec-Driven Development for AI coding agents
Agree on requirements, implement one feature group, and validate against its specification.
Tools: freeGitClaude CodeMCP servers in Claude Code
Connect an HTTP or local MCP server, choose its scope, and test a tool call.
Tools: freeClaude CodeWriting Claude skills that hold up
Organize skill references and validate the workflow on representative tasks.
Tools: freeClaude CodeCustom subagents in Claude Code FREE SAMPLE
Create a specialist agent with explicit instructions and limited tool access.
Tools: freeClaude CodeClaude Code skills FREE SAMPLE
Create a reusable skill, choose its scope, and test it on a sample task.
Tools: freeClaude CodeRoute a coding agent through Free Claude Code
Configure a provider, launch an agent through the proxy, and verify the connection.
Tools: freeAPI keyClaude CodeBuild and share Claude skills
Package a tested skill, upload it to Claude, and share the reviewed version.
Tools: freeClaude CodeClaude Code hooks FREE SAMPLE
Configure PreToolUse and PostToolUse hooks in settings.json to auto-format files and block dangerous commands.
Tools: freeClaude CodeUse the Small Business plugin
Install the plugin, connect task inputs, and review its output before taking action.
Tools: freeClaude CodeClaude Code hooks instead of prompt rules
Replace repeatable prompt rules with hooks and test a session-summary trigger.
Tools: freeClaude CodeUnified Claude Chat and Cowork interface
Combines Chat and Cowork modes into a single conversation interface with automatic task routing and output format controls.
Tools: freeAny text chatLocal models
Ollama · LM Studio · Model hosting08 filesOllama Modelfile and companion
A Modelfile that carries your instructions and sets the context window on purpose, with the checks that show it loaded.
Tools: freeOllamaOllamaRun a local model with Ollama
Install Ollama, download a model, and test it from the terminal.
Tools: freeOllamaOllamaRun Claude Code with a local Ollama model
Connect Claude Code to a local model and verify a small coding task.
Tools: freeOllamaOllamaLocal AI agent with Ollama and PydanticAI
Deploy local LLMs using Ollama and build tool-calling Python agents with PydanticAI.
Tools: freePythonOllamaLM Studio local model runner and server
Download, configure, run, and serve local LLMs via an OpenAI-compatible API to external applications.
Tools: freelm-studioAny AIA CLAUDE.md for apps with no file system
Put your working rules in the system prompt of Open WebUI, LM Studio or Jan, save them to the preset, and prove they loaded.
Tools: freeOpen WebUILM StudioEdit files with LM Studio Bionic
Create a project, select a model, and check its file changes.
Tools: freeLM StudioAny AICheck model hosting constraints before building
Test license fit, memory fit and real inference speed before investing in an app interface.
Tools: freeAny AIAlways-on agents
OpenClaw · Hermes · Pi agent · AI reliability · Agent infrastructure101 filesOpenClaw 2.0 install and setup
Install OpenClaw, configure local and cloud LLMs, create automated agents, and pair with mobile devices.
Tools: freeopenclawAny AIOpenClaw setup
Install OpenClaw, connect a model and optional channel, and check its access.
Tools: freeAPI keyAny AITeach Hermes an API once, then enrich a CSV
Teach Hermes Agent an API once to autonomously enrich CSV records using structured web research.
Tools: free alternativeparallel API keyAny AILean Hermes skills from repeated tasks
Turn a task you keep repeating or correcting into a tested Hermes skill with a short index entry, on-demand references and helper scripts.
Tools: freeAny AIRun Hermes Agent on a VPS with Telegram
Hermes Agent running as a boot-time service on your VPS, answering on Telegram, remembering preferences and running scheduled jobs.
Tools: freeGitAPI keyAdd focused tools to an agent workflow
Extract pages, search code, edit prose, or add a coding workflow to a compatible agent.
Tools: freeNodeAny AISelf-compacting extension for the pi coding agent
Builds an extension enabling autonomous coding agents to manage context window limits and compact themselves using custom prompts.
Tools: freeNodejustBuild AI guardrails that actually run
Wire each guard into its real trigger and prove it blocks a known failure.
Tools: freeAny AIWire a dataset into an AI-facing data layer
Ship data, connector, vocabulary and consumer together, then verify the served result.
Tools: freeAny AIVerify a SQL View with an Independent Oracle
Compare SQL-derived tier metrics with a separate implementation over the same raw rows.
Tools: freeAny AIVerify inherited claims at the owning source
Treat plans and summaries as hypotheses; check each action-driving claim against the source that owns it.
Tools: freeAny AIProve which inference route actually executes
Trace selected branches instead of treating zero cost as proof of a particular provider.
Tools: freeAny AIVerify flight recovery after command loss
Expire stale commands independently and confirm recovery through actual mode telemetry.
Tools: freeAny AIVerify writes in the rendered view
Confirm a write through the user-visible record, not its immediate API response.
Tools: freeAny AITest Separate Entry and Protection in a Simulator
Exercise delayed protection, submission failures, and restart reconciliation using synthetic orders.
Tools: freeAny AIValidate Text Against Explicit Constraints
Check output limits and forbidden text separately, then verify that the response still fulfills its task.
Tools: freeAny AIPreserve experiment runs and count every trial
Keep immutable run artifacts and a complete variant ledger before selecting results.
Tools: freeAny AIValidate AI Content Before Committing
Accept generated document content only after schema validation, while preserving existing styling.
Tools: freeAny AITest verification ladders without network calls
Inject one lookup seam to exercise source agreement, fallback, errors, and freshness boundaries deterministically.
Tools: freeAny AIValidate Locking Without Launching Real Workers
Exercise contention, process detection, and clone isolation with temporary locks and fake launchers.
Tools: freeAny AITest Geographic Coverage Invariants
Separate stable synthetic grain tests from a live-data smoke test that respects the service footprint.
Tools: freeAny AITest a UI control by its downstream effect
Catch a picker that passes values through several layers but changes nothing.
Tools: freeAny AIExpose retrieval failures through fallback
Keep retrieval infrastructure errors distinguishable from valid searches with no answer.
Tools: freeAny AIKeep live AI updates from overwriting user edits
Validate streaming updates against the whole document and let local edits win through completion.
Tools: freeAny AIScope capabilities to each pipeline stage
Give fetch stages spending access and notification stages only their own send capability.
Tools: freeAny AISeparate verified facts from inference
Give exact sourced claims and useful hypotheses separate generation and validation rules.
Tools: freeAny AIPrevent an action from approving its own plan
Make approval a separate recorded transition and require the simulated submission to match the approved terms.
Tools: freeAny AIScope a recurring defect before fixing it
Find every implementation of the failing operation before changing the first example.
Tools: freeAny AIVerify revocation stops active media
Authorize each media session and test revocation while a viewer is connected.
Tools: freeAny AIRestore global module mocks after each test file
Prevent test order from turning an isolated pass into a full-suite failure.
Tools: freeAny AIResolve the subject once for every build path
Use one record resolver across entry points and preserve an unresolved subject instead of substituting a nearby match.
Tools: freeAny AIDemote Duplicate Signals to Cross-Checks
Stop a summary engine from voting again on concepts already covered by dedicated inputs.
Tools: freeAny AIRecord Deliberation Confidence Changes
Preserve independent initial confidence and final confidence to measure what deliberation actually changes.
Tools: freeAny AIPrevent lookahead in historical backtests
Limit each signal to information available at its decision time.
Tools: freeAny AIRetire legacy engines while protecting customers
Freeze customer-bearing units while replacing the engine; archive obsolete code and docs with recoverable history.
Tools: freeAny AIKeep Incompatible Signal Baselines Separate
Keep signals separate when their questions and comparison baselines are incompatible.
Tools: freeAny AIPrepare a Voice-Cloning Reference
Control reference length, language, and voice instructions before judging cloned speech.
Tools: freeAny AICheck evidence before spending writer calls
Validate adapter evidence before generation and bound repeated rejected work across scheduled runs.
Tools: freeAny AINormalize and Validate Structured Model Responses
Extract answer text from mixed content blocks before validating structured output.
Tools: freeAny AIRegister computed facts as narrator anchors
Give the writer and claim validator the same approved facts instead of hiding facts in framing.
Tools: freeAny AIMatch forbidden labels without substring false alarms
Check rendered output for prohibited labels while allowing unrelated words.
Tools: freeAny AILint causal claims between agent outputs
Flag causal connectors joining different agent references while allowing explicit source attribution.
Tools: freeAny AIPropagate freshness and trust through confidence
Compute confidence from source quality and upstream dependencies while exposing its limits.
Tools: freeAny AIKeep an explainer chat honest without live data
Constrain an ungrounded chat to capabilities and direct precise data requests to a grounded workflow.
Tools: freeAny AIMake repaired migration exemptions fail visibly
Use inverted assertions so a fixed exception cannot remain silently exempt.
Tools: freeAny AIShow an honest degraded state when feeds fail
Define a floor below which an empty-tolerant page must report unavailable data.
Tools: freeAny AIProve checks with deliberate failure fixtures
A detector passes only after catching a known failure and accepting a valid case.
Tools: freeAny AIGround charts and answers on one data artifact
Publish deterministic, grain-specific data once, then use it for charts and grounded answers.
Tools: freeAny AIRebuild frozen deliverables after generation changes
Detect invented figures, minted links, missing disclosures and caption-limit regressions on fixed inputs.
Tools: freeAny AIGenerate Tool Traces Through a Verifier Gate
Separate tool selection from prediction generation and retain rejected traces without admitting them to accepted data.
Tools: freeAny AIGate Records with Pure, Versioned Verifiers
Admit only passing candidates, then independently reverify saved records with immutable offline rules.
Tools: freeAny AIGate and Route Pasted Listing Links
Default fetching off, route link requests exclusively, and request missing facts instead of guessing.
Tools: freeAny AISeparate sunk spending from a resource decision record
Prepare a forward-looking resource review while preserving relevant costs and history.
Tools: freeAny AIFlag Retrospective Forecast Contamination
Keep retrospective questions inside a model's training window from being counted as clean forecast tests.
Tools: freeAny AITest kill-switch latch creation in isolation
Exercise the enforcement path in temporary state and confirm a simulated breach creates its latch.
Tools: freeAny AIReview Untrusted Posts Without Executing Them
Keep scraped instructions inert, label evidence quality, and escalate consequential recommendations.
Tools: freeAny AIEnforce guards in the action path
Put each critical guard in the module that performs the action, then verify the submit path enforces it.
Tools: freeAny AIEmit Normalized Trial Facts
Convert trial evidence into typed contexts and stable fields that batch reports can aggregate.
Tools: freeAny AIExpose rejected prose in build reports
Make silent narrative drops visible without weakening the claim gate.
Tools: freeAny AIEdit generated content through a gated rebuild
Change structured inputs and regenerate through the original gates instead of editing generated prose directly.
Tools: freeAny AIExercise kill conditions with seeded cases
Prove breach detection and alert delivery using isolated synthetic fixtures.
Tools: freeAny AIDraft Evidence-Grounded Answer Keys
Define required facts, connections and reasoning before grading a scenario response.
Tools: freeAny AIMake research discoverable to coding agents
Give agents a searchable route to research that ordinary repository searches miss.
Tools: freeAny AIAudit model additions before composing factual prose
Allow code-written facts while rejecting digits introduced by the model.
Tools: freeAny AIDiagnose Generators with Verifier Kill Reports
Compare identical task corpora and isolate semantic failures hidden by valid schemas and tool calls.
Tools: freeAny AIChoose guard types before building a feature
Pair concrete failure modes with controls that can observe them during design.
Tools: freeAny AIDesign an agent workflow from its target answer
Identify the questions, evidence and conflict rules needed before building one useful slice.
Tools: freeAny AIKeep Agent Actions Within Their Deadline
Limit each model call and switch to a deterministic policy when the response cannot supply usable actions.
Tools: freeAny AIInclude pending orders in simulation limits
Count unfilled commitments alongside simulated holdings so repeated submissions cannot bypass exposure limits.
Tools: freeAny AICompute claims before asking AI for prose
Give the narrator settled facts and omit any paragraph that fails its claim gate.
Tools: freeAny AICompare Speech Quality Controls
Use controlled listening comparisons to select speech settings and measure their runtime cost.
Tools: freeAny AICompare Distillations on Identical Evidence
Evaluate wording, factual fidelity, classifications, and dropped spans without overstating recall.
Tools: freeAny AIClassify billing refusals at the call boundary
Route a confirmed billing refusal through the existing incident path without retrying it.
Tools: freeAny AICap rule-guided synthesis revision
Revise a failing synthesis twice, then expose unresolved violations for human review.
Tools: freeAny AICheck builder repeatability across fresh contexts
Compare repeated builds while isolating only declared nondeterministic fields.
Tools: freeAny AIKeep internal errors out of API responses
Return a generic error while retaining diagnostic detail in protected logs.
Tools: freeAny AIStop AI reports inventing relationships
Audit comparisons, trends, counts and sequences even when every number is real.
Tools: freeAny AIMatch verification evidence to bug behavior
Choose a real observation that can expose the failure being fixed.
Tools: freeAny AIApprove the exact reviewed page version
Approve only when the current page matches the reviewed version and the brief actually displayed.
Tools: freeAny AIApply domain constraints before synthesis
Evaluate binding domain rules before accepting a synthesized recommendation.
Tools: freeAny AIVerify Protocol Routes With POST Discovery and Calls
Catch mount errors that GET probes miss by exercising discovery and a real tool call.
Tools: freeAny AISeparate Drone Control from Video
Keep flight authority separate from observation, with recovery independent of the hub.
Tools: freeAny AIShare classification across warning and stop gates
Use one classifier so advance warnings and final enforcement cannot disagree.
Tools: freeAny AIScope Obstacle Checks to Each Command Path
Validate obstacle coverage and sensor-loss behavior for the modes and commands actually used.
Tools: freeAny AIRoute tool calls by supported capabilities
Match questions against available evidence and coverage instead of broad topic keywords.
Tools: freeAny AIRestrict downstream agents to validated outputs
Expose compact upstream results through explicit dependency edges and reject incomplete contracts.
Tools: freeAny AIRequire read evidence from the editing session
Keep another session's recent read from satisfying an editor's preparation gate.
Tools: freeAny AIRegister plan scope when a spec is saved
Capture scope after spec writes, merge it into the session plan, and report overlaps.
Tools: freeAny AIProve Aircraft Interfaces Before Selection
Bench-prove commands, telemetry and recorder-bound video for the exact aircraft configuration.
Tools: freeAny AISubmit Orders Once Per Observed Turn
Use visible state, validate per-unit actions, and recover from stale turns without duplicating accepted submissions.
Tools: freeAny AISerialize Runners Across Isolated Worktrees
Use one account-wide lock and detect processes that launched outside it.
Tools: freeAny AIIsolate Sessions Before Integrating Changes
Give each session its own working tree and integrate committed changes through fast-forward updates.
Tools: freeGitAny AIMonitor a home agent server
Separate host resource visibility, container metrics and proven alert delivery.
Tools: freeAny AIRequire a durable session log before pushing
Preserve session history and block pushes that omit its update.
Tools: freeAny AIDistinguish a failed agent from a quiet agent
Monitor failed runs, missed runs and invalid outputs as three separate failure paths.
Tools: freeAny AIExpose failures in required rule loading
Prevent missing, blank or unreadable rule files from silently replacing the active rule set with stale defaults.
Tools: freeAny AIEvaluate Shared-Repo Agent Coordination
Test overlapping plans, exclusive file access, automatic recovery, queue fairness, and coordination context.
Tools: freeAny AICoordinate parallel agents editing shared files
Compare planned scopes, gate conflicting writes, and release claims using version-control evidence.
Tools: freeAny AIClaim a Handoff Before Launching
Give each handoff a visible owner so duplicate recipients cannot independently launch the same work.
Tools: freeAny AICarry answer context in every tool payload
Deliver the synthesis dossier and compact rules together so follow-ups can reuse retrieved context.
Tools: freeAny AICapture corrections before answering
Persist user issues immediately and carry unresolved items across sessions.
Tools: freeAny AIOpenAI & editors
Codex · ChatGPT agents · Cursor · Antigravity08 filesCodex Ultrafast mode on the Pro 500 plan
Configure Ultrafast mode in Codex to rapidly generate interactive WebGL, 3D, and full-stack web applications.
Tools: paidCodexSix-step method for Codex skills
Create, test, verify, and optimize markdown-based skills for AI agents.
Tools: freeCodexClaude CodeNavigate Codex CLI sessions
Fork a conversation, inspect agent threads, and check session usage.
Tools: freeCodexStart a project with Codex
Open a local project, plan a change, and review the implementation.
Tools: freeOpenAI accountCodexChatGPT Browser and Computer Use
Automate research, web workflows via Chrome, and local desktop applications using natural-language instructions.
Tools: freeOpenAI accountAny text chatCursor Projects agent coordinator
Coordinates autonomous multi-agent coding tasks across cloud and local machines with persistent threads and event triggers.
Tools: freeCursorGoogle Antigravity 2.0 agent platform
Dispatches and manages parallel AI agents to plan, code, debug, and run automated tasks.
Tools: freePythonAny AIAntigravity Remote Control
Monitor and steer coding agents across machines from a mobile device without syncing local build environments.
Tools: freeGoogle accountAny AIAutomation & repos
n8n · Browser agents · Computer skills · GitHub repos · App architecture · Monitoring products64 filesn8n Agents tab (early preview)
Build, configure, and deploy standalone or workflow-integrated AI agents natively inside n8n without complex node chains.
Tools: freen8nAPI keyModel benchmark for n8n workflow generation
Compares six frontier AI models on cost, speed, and reliability when generating complex n8n workflows via MCP.
Tools: freen8nAPI keyn8n Telegram agent
Build and connect an automated personal AI assistant to Telegram using n8n Agents, MCP tools, and skills.
Tools: freen8n accountTelegram accountn8n MCP and skills for Claude Code
Install n8n skills and configure MCP in Claude Code to autonomously generate, configure, and test n8n workflows.
Tools: freen8nClaude Coden8n instance-level MCP setup
Connect AI coding agents to an n8n instance to generate and edit workflows automatically.
Tools: freen8nClaude CodeConnect n8n agents and workflows
Build an agent, expose a workflow tool, and call the agent from another workflow.
Tools: freeAPI keyAny AIYour first AI agent in n8n
Build Q&A ingestion and retrieval workflows, then test answers against stored records.
Tools: freeAPI keyAny AIModel Context Protocol for Playwright QA
Connects AI agents to testing tools, automation, and databases using Model Context Protocol (MCP) and Playwright.
Tools: freeNodePythonClaude Code Chrome extension setup
Connect Claude Code to Google Chrome to automate browser navigation, capture screenshots, and inspect web pages.
Tools: freeClaude CodeLinux command-line troubleshooting tools
Run Linux commands inside Docker to inspect logs, find files, check ports, and edit configuration files.
Tools: freeDockerAny AIAI web scraping and classification pipeline
Scrape dynamic web pages using Playwright and Claude Code, route through proxies, and classify text using Jev.
Tools: freePythonNodeIsolate IoT devices on an OPNsense VLAN
An IoT VLAN on OPNsense with its own DHCP range and internet access, blocked from your trusted networks.
Tools: freeAny AIPreserve the original command's exit status
Read saved output after capturing the producer's status, not through a masking pipeline.
Tools: freeAny AIAvoid quoting bugs across Windows and Linux
Put complex commands in scripts and verify values after crossing a shell boundary.
Tools: freeAny AITest redaction with a known matching fixture
Confirm a redactor changes fake credentials instead of merely compiling successfully.
Tools: freeAny AIdrive-screen coding agent skill
Drives desktop GUIs using CLI Python scripts executed directly by terminal coding agents without dedicated computer-use harnesses.
Tools: freePythonAny AIAdd testing and design tools to a coding agent
Install selected tools for UI checks, skills evaluation, and code linting.
Tools: freeNodeAny AIInstall tools for an AI development workflow
Set up a selected converter, terminal, review tool, gateway, or diagramming skill.
Tools: freeNodePythonMap an app workflow to running components
Give every step a runtime, owner, state contract and honest implementation status.
Tools: freeAny AIVerify a Vendor Contract Before Coding
Use live documentation and one real response to establish the API contract before implementing an integration.
Tools: freeAny AITypecheck scripts excluded from the app build
Give scripts an explicit compiler project instead of trusting inferred editor diagnostics.
Tools: freeAny AITriage routes for safe revalidation
Match public-route caching to source cadence and measure actual egress before and after.
Tools: freeAny AIUse one rule to surface work needing attention
Share attention logic across command and session views so draft and clockless work cannot disappear.
Tools: freeAny AIKeep lookup links separate from source citations
Make feed items navigable without turning convenience links into evidence in exported notes.
Tools: freeAny AIScore Outcomes Independently of Publication
Keep outcome grading running when optional feeds or narrative publication fail.
Tools: freeAny AIRegister validators by content shape
Let surfaces share validation by declaring the kind of content they produce.
Tools: freeAny AIRoute builds by explicit tags across entry points
Keep editable prompt text separate from the identity that selects a builder.
Tools: freeAny AIRoll out generated content with a cold fallback
Approve a single-entity pilot and batch previews before switching readers to new structured content.
Tools: freeAny AIRetry transient profile failures before degrading
Treat confirmed signed-out state differently from a temporary profile-fetch failure.
Tools: freeAny AIRender Saved Charts as Share Cards
Generate consistent PNG cards while preserving chart values and source provenance.
Tools: freeAny AIRender answers by question complexity
Keep everyday answers conversational and reserve full audit structure for explicit audit requests.
Tools: freeAny AIDetect redirects that shadow real pages
Catch a deployed route that cannot render because a redirect wins first.
Tools: freeAny AIServe Files With Expiring Private Tokens
Protect downloadable repairs with loopback serving, per-request hashes, and bounded secret-token lifetimes.
Tools: freeAny AIGuard Only Corridor-Dependent Lookups
Use the resolved county to retain applicable results and skip only the lookup requiring a corridor ID.
Tools: freeAny AIPackage runtime assets with their routes
Include native dependencies and disk-read assets before shipping server-rendered outputs.
Tools: freeAny AIIsolate SVG IDs for Repeated Rendering
Keep gradients, masks, clips, and local references attached to the correct icon instance.
Tools: freeAny AIIsolate Dataset Load and Parse Failures
Keep missing or malformed datasets from aborting an otherwise usable multi-dataset response.
Tools: freeAny AIGate Actions by Metered Usage
Enforce weekly action limits with configuration that defaults to unlimited access.
Tools: freeAny AIFork content edits to preserve shared snapshots
Create a new version for refreshed data or content changes while keeping the shared original frozen.
Tools: freeAny AIStop failed reads from creating duplicate projects
Separate a confirmed empty project list from a failed lookup before automatic creation.
Tools: freeAny AIConsolidate Database Client Imports
Remove a competing client configuration that can silently break authentication.
Tools: freeAny AIBridge a proven renderer into a new project
Transfer an established rendering capability through a small specification contract.
Tools: freeAny AIProve the core flow before adding product gates
Drive the real user journey before designing pricing, throttling, or additional restrictions.
Tools: freeAny AIGate Paid Exports with User-Scoped Reads
Separate privileged billing lookup from user-scoped export reads and define billing-outage behavior.
Tools: freeAny AIConfirm and revoke a scoped change decision
Tie a short-lived approval to a verified identity and recheck the target before confirmation.
Tools: freeAny AIBind Page Approval to Content Changes
Invalidate approval when meaningful page content changes while allowing freshness metadata to update.
Tools: freeAny AIValidate Feed Shapes Before Trusting Zero
Inspect live responses and repair parsing before trusting an empty discovery feed.
Tools: freeAny AITrigger Brief Review on Title Changes
Detect headline corrections under stable IDs without reviewing every rotating search excerpt.
Tools: freeAny AIRun a Source-Backed Monitoring Loop
Deduplicate collected items, rewrite a linked brief when new information arrives, and notify only on a brief change.
Tools: freeAny AIBuild a monitor from probe to dashboard
Normalize live records, preserve a baseline, detect changes and render a finished dashboard.
Tools: freeAny AIMeasure Operator Review Load During a Pilot
Record reviews and minutes per subject over seven days.
Tools: freeAny AIRetain and Recheck Discrepancies
Preserve unresolved observations and notify users when comparable observed states change.
Tools: freeAny AIAdd time bounds to aggregate usage counters
Keep a counter capable of answering when activity began and last occurred.
Tools: freeAny AIProvision a Tracked Subject from a Request
Map a request to probed sources, a persistent monitoring unit, and its requester-facing page.
Tools: freeAny AIProve the Monitoring Customer Journey
Test request intake, published results, delivered changes, quiet repeats, and notification controls before charging.
Tools: freeAny AIArchive Retired Code Without Breaking Active Imports
Trace active and frozen consumers before moving retired components out of current discovery.
Tools: freeAny AISend notifications only on real changes
Write the dashboard first, then notify on meaningful diffs with honest delivery outcomes.
Tools: freeAny AIIngest Tracked Events Idempotently
Merge repeated event IDs and distinguish stale observation from an empty scene.
Tools: freeAny AIGenerate watcher coverage from workflow files
Derive watcher subscriptions and monitoring metadata from one generated workflow manifest.
Tools: freeAny AIBuild public examples from real product output
Generate example cards and pages from sourced, committed output rather than hand-entered marketing figures.
Tools: freeAny AIAdd customers through configuration
Keep one probe, diff and rendering engine while each customer owns settings and history.
Tools: freeAny AIConsolidate pipeline health reporting
Combine existing health checks into one machine report that backs the operator inventory.
Tools: freeAny AICompare Observed Offer State
Compare catalog prices, processed listings, and variant-specific page evidence without treating uncertainty as healthy.
Tools: freeAny AITest data availability before accepting work
Run the real extraction against the real target and issue an evidence-based viability receipt.
Tools: freeAny AIData & workflows
Data engineering · Email production · Operations213 filesCompute ZIP Rent Yields With Sparse Flood Data
Combine value, monthly rent, and optional flood adjustments while preserving missing and implausible results.
Tools: freeAny AIDefine Export Fields in One Registry
Drive every export through an ordered public-field schema that excludes internal data.
Tools: freeAny AIVerify Identity Before Comparing Records
Activate only verified deterministic mappings and keep unmatched records visible in coverage.
Tools: freeAny AIKeep Calendar Buckets Independent of Session Timezones
Check date types and pin timestamp bucketing to a declared calendar timezone.
Tools: freeAny AIDetect Stale Price Feeds
Inspect record timestamps and collector status before accepting a feed as current.
Tools: freeAny AIValidate Browser Date Filters
Detect silently rejected date values before trusting search results.
Tools: freeAny AICentralize exact normalized street comparison
Handle compound-word spacing consistently without allowing partial matches.
Tools: freeAny AIBuild latest snapshots with calendar change rates
Calculate monthly and annual changes using the newest observation within a seven-day calendar tolerance.
Tools: freeAny AIVerify a Listing Link Selects the Correct Variant
Repair an exact variant-link mismatch and verify the destination by fetching it.
Tools: freeAny AIRepair a Stale Override at Its Owning Source
Test simultaneous source precedence and preserve unrelated fields through the next synchronization.
Tools: freeAny AIValidate Sale Timing Across Both Boundaries
Correct an established sale interval and observe effective prices before, during, and after it.
Tools: freeAny AIRepair Listing Availability From Sellability
Align a listing with established storefront sellability while leaving physical inventory unchanged.
Tools: freeAny AIFill Missing Identifiers From Verified Catalog Data
Transfer an authentic identifier already held for the exact variant; refuse invented replacements.
Tools: freeAny AISuppress Thin-Sample Local Sale Medians
Calculate local housing-price medians with a labeled county fallback for groups containing fewer than 20 sales.
Tools: freeAny AICorrect unit errors with superseding records
Fix ambiguous units without erasing the original prediction or its eventual outcome.
Tools: freeAny AIBuild a staged, rerunnable data refinery
Preserve raw records, filter and synthesize relevant facts, then validate output before replacing an existing artifact.
Tools: freeAny AIHarden ingestion with keys and contracts
Choose merge or replacement from observed key behavior and guard required fields.
Tools: freeAny AIName computed quantities from source semantics
Check what a field measures before attaching a stronger label to correct arithmetic.
Tools: freeAny AISeparate source capability from ingested data
Record what a source exposes alongside the subset your pipeline actually stores.
Tools: freeAny AIAnchor report values to a source snapshot
Give every decision-facing value an observation time and an identifiable snapshot.
Tools: freeAny AIDeliver and Verify Spreadsheet CSV Files
Preserve Unicode, serialize every cell, and verify downloaded values in the target spreadsheet.
Tools: freeAny AISeparate Trial Facts From Batch Analysis
Aggregate normalized facts automatically and configure semantic analysis separately.
Tools: freeAny AIKeep nearby and resident amenities distinct
Preserve location grain and uncertainty instead of turning proximity into access.
Tools: freeAny AIKeep capped histories from producing false totals
Expose truncation and withhold totals across unrelated record cycles.
Tools: freeAny AIScope Reconciliation Checks by Grain and Window
Validate signed summary totals only within matching scope; keep that check separate from detail-row verification.
Tools: freeAny AIScope an Ingestion Source Before Loading
Inventory the source schema, choose its canonical root, and connect the consuming product before ingesting.
Tools: freeAny AIRun opt-in value and schema quality probes
Configure table-level value checks and compare live column types with reviewed baselines.
Tools: freeAny AIRetain raw API responses for later parsing
Persist successful source responses before deriving downstream fields.
Tools: freeAny AIParse typed families from stored response envelopes
Recover one-to-many data from retained payloads without buying the same response again.
Tools: freeAny AIReject Ambiguous Dates at Rule Boundaries
Withhold partial dates when their possible values cross different rule windows.
Tools: freeAny AIReconcile Primary Facts with Secondary Crosschecks
Reconcile source coverage and surface proxy disagreements without letting them overwrite primary facts.
Tools: freeAny AIReconcile Coverage Against Record Geography
Separate missing geographic mappings from out-of-footprint records before widening dataset coverage.
Tools: freeAny AIMake serving views read one typed data root
Remove duplicate parsing while preserving consumer-facing validation.
Tools: freeAny AIRatify Data Authorities by Purpose
Make each source recommendation independently approvable for the question it answers.
Tools: freeAny AIParse Ranges Without Hiding Missing Indicators
Preserve range endpoints, support alternate phrasing, and fail ingestion when any required indicator produces no rows.
Tools: freeAny AICheck active ingest destinations after changes
Detect registered pipelines whose claimed destination was never created.
Tools: freeAny AIProbe data using the consumer's query shape
Keep an expensive count or wrong schema from creating a false outage diagnosis.
Tools: freeAny AIProbe real records before building a pipeline
Check keys, fields, pagination and runtime on a small pull before committing to ingestion.
Tools: freeAny AIPreserve Unknowns in Verified Snapshots
Require evidence for negative findings and keep interpreted document fields outside verified facts.
Tools: freeAny AIPreserve Observation Meaning and Vintages
Keep measurement identity, missingness, availability, and revisions explicit.
Tools: freeAny AISeparate Valuation Sources and Labels
Keep assessed values, asking prices, recorded sales, and value indexes in their proper roles.
Tools: freeAny AIPreserve enriched fields during routine upserts
Keep a sparse recurring feed from erasing values supplied by enrichment.
Tools: freeAny AIPreserve source date precision through rendering
Use the same grain-aware formatter for visible dates and permitted model numerals.
Tools: freeAny AIPrepare Survey Microdata for Calibration
Select appropriate person-level data, check coverage, extract observed values, and derive complete calibration margins.
Tools: freeAny AIParse signed percentages without hiding conflicts
Accept signed percentages, reject currency-shaped strings, and expose contradictory signs.
Tools: freeAny AIGate a data-path cutover on output parity
Compare numeric, aggregate, ranked-output, and table parity across three rebuilds, then prove mismatch detection.
Tools: freeAny AIKeep repeated scrapes from renewing old news
Rank content by publication or preserved first-seen time instead of its latest scrape.
Tools: freeAny AIRegister a Corridor Across Profile and City Registries
Keep corridor identity, alias resolution, city membership, and counts consistent during onboarding.
Tools: freeAny AIGuard Fraction and Percentage Swaps
Prevent a source replacement from silently changing a share by a factor of one hundred.
Tools: freeAny AIConvert Listing Totals to Unit Prices
Establish whether a price covers one item or the entire listing before comparing values.
Tools: freeAny AIReport Pipeline Freshness From a Cadence Registry
Use registered cadences and actual load metadata to publish a nonblocking stale-pipeline summary.
Tools: freeAny AIMark clipped source lists as incomplete
Prevent a truncated entity list from being consumed as the complete record.
Tools: freeAny AIMap a dataset to a constrained schema
Separate observed mappings from grounded inference, normalize values, and validate output.
Tools: freeAny AIMake a backfill resumable per record
Use missing-field selection and stable record keys instead of restarting a sampling grid.
Tools: freeAny AILog generated predictions and linked outcomes
Persist every synthesis run and join later observations to its original prediction.
Tools: freeAny AISize History Windows for Reporting Delays
Retrieve enough calendar history to retain the usable observations required by a rolling calculation.
Tools: freeAny AICarry geographic grain with computed values
Compute wider statistics from underlying records and keep their scope attached.
Tools: freeAny AIInventory a Records Search Output Schema
Capture every result field and unresolved interpretation before designing ingestion.
Tools: freeAny AIImplement a Deterministic ZIP Resolver
Resolve scope and county from static data, preserving unknown classifications and stable place choices.
Tools: freeAny AIQuarantine Suspect Extraction Rows
Block validation failures from downstream use until a reviewer explicitly resolves them.
Tools: freeAny AIHold Data With Conflicting Measure Definitions
Block release when accurate values may represent a different measure from the one the destination consumes.
Tools: freeAny AIHand Off Immutable Observation Exports
Exchange read-only observation files with a manifest instead of sharing a mutable database.
Tools: freeAny AIExclude Rollups from Local Aggregates
Prevent regional and intermediate totals from entering local selections or sums.
Tools: freeAny AICheck Geographic Coverage of Latest Views
Expose a latest-record view that silently drops part of its intended service area.
Tools: freeAny AIGuard destructive refreshes before writing
Keep good data when a replacement pull is empty, incomplete or missing required fields.
Tools: freeAny AIResolve geographic entities with geometry
Use authoritative boundaries with coordinate and ambiguity checks when names do not encode membership.
Tools: freeAny AIGenerate Validated Active Flags
Convert supported research into at most five schema-valid event flags.
Tools: freeAny AIRequire complete coverage before reporting zero
Preserve held data during outages and prevent missing collection windows from becoming invented zeros.
Tools: freeAny AIGate History in a Ragged Time-Series Panel
Determine eligibility per series and count usable series-days instead of quoting the nominal date span.
Tools: freeAny AIRequire Schedules and Dry Runs With New Pipelines
Generate pipeline companions together and block changes that omit scheduling or dry-run support.
Tools: freeAny AIGate Retirement on Replacement Readiness
Keep overlapping datasets until the replacement exists and approved consumers have moved.
Tools: freeAny AIGate batches with content contracts
Quarantine invalid rows before merge; abort only when contamination exceeds an explicit threshold.
Tools: freeAny AIExclude frozen dates from market histories
Use a same-date reference bar to prevent closed-market snapshots from becoming new observations.
Tools: freeAny AIAssign Table Values by Header Geometry
Map numeric cells to header positions so extra columns cannot silently shift field assignments.
Tools: freeAny AIApply the Same Price Floor to Every Served Query
Prevent raw-table loaders from bypassing the price contract used by authoritative views.
Tools: freeAny AIResolve email fields with a cost-aware source ladder
Use held data first, join existing records, and call a paid source only for a specific gap.
Tools: freeAny AIKeep provisional values inside editable fields
Prevent a convenient starting value from becoming an uncorrectable factual claim.
Tools: freeAny AIDiscover Listing Pages and Validate Join Keys
Use list view to expose detail links, then verify URL identifiers against displayed listing numbers before joining records.
Tools: freeAny AICheck Whether a Repair Survives Synchronization
Rerun the upstream writer, detect restored errors, and correct ownership instead of entering a write loop.
Tools: freeAny AIAdd incremental extraction per source
Classify each source before choosing a cursor, merge, or full replacement strategy.
Tools: freeAny AIEnrich the scope actually present in a widened pool
Use records' own scope keys after fallback expands the result set.
Tools: freeAny AICross-check ingestion identities in CI
Detect configuration drift by comparing registry entries with code, workflows, consumers, and landed data.
Tools: freeAny AIUse direct counts for dataset-size claims
Replace stale planner estimates with a live count of the dataset being described.
Tools: freeAny AICorrect Calendar-Based Year-Over-Year Specs
Replace row-offset comparisons with the specified calendar tolerance rule before implementation.
Tools: freeAny AIConfirm a Data Source’s Full Scope
Enumerate a bounded source family and verify ingestion coverage against its authoritative catalog.
Tools: freeAny AIEscape CSV cells at one output boundary
Route every exported cell through the tested escaper and verify formula-shaped input remains text.
Tools: freeAny AIClassify Off-Market Listing Transitions
Resolve listing departures without mistaking pending closures or old sales for current outcomes.
Tools: freeAny AIShow Price Basis in Comparable Bar Labels
Build sorted price bars with visible estimate and listing qualifiers, then attach them directly to the answer.
Tools: freeAny AIPreserve feed identity through calculations
Carry source-feed labels through filtered history and derived values instead of hardcoding provenance.
Tools: freeAny AICache and Reconcile Citation Detail
Replace repeated full citation scans with one reusable extract, guarded by exact count reconciliation.
Tools: freeAny AIBuild and Verify a Corridor Profile
Capture context, assemble evidence, preview generated sections, validate, and verify the saved profile.
Tools: freeAny AIBuild an Aligned Two-Tier Monthly Dataset
Preserve unmatched tiers while aligning monthly series and merging them at a stable grain.
Tools: freeAny AIKeep data registries wired to consumers
Record source coverage, authoritative roots, obligations, and their live consumers.
Tools: freeAny AIBuild a Producer from Recorded Source Bodies
Replay exact fetched bodies offline and bind each extracted field to its actual retrieval.
Tools: freeAny AIBind chart and headline to one source total
Generate a headline and labeled donut from one detail table, then align preview and live output.
Tools: freeAny AIBackfill Missing Listing Dates Safely
Recover missing listing dates in resumable batches without generating listing activity.
Tools: freeAny AIAudit Profiles With Documented Exceptions
Separate complete profiles, justified nulls, and missing coverage without inventing measurements.
Tools: freeAny AIAttribute Usage to Account Owners
Make account limits count the same owner's actions across web and tool interfaces.
Tools: freeAny AIApply a Prepared Results-Access Migration
Run an existing access-policy migration and verify authenticated users can see newly generated results.
Tools: freeAny AICalculate ratios only on matching dates
Prevent a lagging series from silently producing a ratio between different observation dates.
Tools: freeAny AIAdd a Domain to a Data Brief Factory
Extend a shared brief pipeline with a source adapter and deterministic analysis, preserving fact provenance.
Tools: freeAny AIVerify the reply inbox end to end
Prove replies arrive in a readable inbox before depending on reply-based support or stop requests.
Tools: freeAny AIValidate email rendering before delivery
Test the real builder and renderer, then inspect both layout and factual output.
Tools: freeAny AIReject misleading chart input mappings
Prevent negative bars and categorical labels from acquiring false visual or date meanings.
Tools: freeAny AIValidate cached prose against the receiving artifact
Reject cached commentary containing numbers unsupported by its smaller destination.
Tools: freeAny AITrace every rendered number to a source fact
Bind typed facts into fixed output slots and lint the final artifact.
Tools: freeAny AITrace Field Preservation Through Document Builders
Follow complete input facts into document blocks and identify the first missing value or unverified boundary.
Tools: freeAny AIDesign email recipes around one pipeline
Let recipes choose content while a shared seam assigns layout and one renderer produces output.
Tools: freeAny AIRender email and social charts from one specification
Compute geometry in code and feed identical chart specifications into each surface's image renderer.
Tools: freeAny AIShare expanded brand tokens across email and social
Resolve typography, colors and surfaces from one branding record for both output types.
Tools: freeAny AISeed required blocks before applying brand data
Mirror the production canvas when a recipe reads brand information from existing blocks.
Tools: freeAny AISave Before Sending Personalized Email
Send the persisted design and substitute recipient fields separately for each recipient.
Tools: freeAny AIRoute Email Builds Through a Total Fallback
Make every email build use a registered grid, including unmatched requests and invalid builder results.
Tools: freeAny AIExtend equivalent emails through the same builder
Change declared variant fields instead of copying a sibling email's construction logic.
Tools: freeAny AIRender sentence banks without partial claims
Fill typed slots from resolved facts, drop incomplete sentences whole, and keep generated prose additive.
Tools: freeAny AIBake an email photo badge into the image
Composite the badge server-side and preserve the original photo if processing fails.
Tools: freeAny AIRequire a submitted form to unsubscribe
Make unsubscribe links display a confirmation form so automated link fetches do not remove recipients.
Tools: freeAny AIPreserve supplied text outside AI rewrite slots
Protect authorized verbatim blocks from model edits, truncation, and schema caps.
Tools: freeAny AIRetain debt for failed email delivery
Enforce the promised destination, confirm publication before sending, and preserve failed delivery for retry.
Tools: freeAny AIPreserve Distinct Image Slots
Tag generated images by role so refreshing one preserves other images and manual uploads.
Tools: freeAny AICarry reader requirements into a new email product
Turn formatting and reader expectations into explicit acceptance checks for the new output.
Tools: freeAny AIFit chart labels with real font widths
Replace character-count clipping with measurements from runtime-accessible fonts.
Tools: freeAny AIParameterize repeated acceptance harnesses
Share verification logic while preserving each output's fixture and assertions.
Tools: freeAny AIRender previews at the real output width
Prevent iframe width and scrollbars from fabricating wrapping defects.
Tools: freeAny AIApply Branding Without Changing Facts
Use one brand mapping for live previews while leaving generated factual content untouched.
Tools: freeAny AIMake acceptance renders safe and correctly located
Ensure a gate's prescribed render writes its actual target without enabling paid lookups.
Tools: freeAny AIMirror the hero and deduplicate its gallery
Keep the leading image durable without repeating it in supplementary photos.
Tools: freeAny AIKey cached assets by their rendered bytes
Make visual changes produce new asset URLs even when the input specification stays unchanged.
Tools: freeAny AIGate personalized recurring email sends
Build per-recipient issues in bounded batches, preview them, and require review before a new recurring product sends.
Tools: freeAny AIGate a Data Brief Before Delivery
Validate inputs, render and score the complete brief, then refuse delivery whenever a required gate fails.
Tools: freeAny AIResolve Brands Through Validated Fixtures
Prefer trusted stored brands, retain live enrichment as a fallback, and report the origin of each selection.
Tools: freeAny AIFill a Fixed Email Skeleton From Sources
Reuse sourced filling while leaving unavailable figures open and recovering safely from sourcing failures.
Tools: freeAny AIExtend a Typed Document Block
Register a new block across typing, validation, defaults, rendering, editing, and branding.
Tools: freeAny AIPrecompute validated email commentary
Cache checked prose for bounded subjects and prove the email builder consumes it.
Tools: freeAny AIBuild an email grid with consistent typography
Use one layout grammar and tokens that keep font size, weight and line height together.
Tools: freeAny AICheck email colors, buttons and links
Keep meaning visible without color or images and verify every action reaches its promised destination.
Tools: freeAny AIRecord which builder produced each document
Validate recipe keys and carry truthful provenance across document versions.
Tools: freeAny AIVerify branding through the real profile path
Render with an account profile to catch fields lost between account and project.
Tools: freeAny AISuppress restricted facts before narrative generation
Remove facts the recipe must not reveal from both the grid and model input.
Tools: freeAny AIFit footnotes by choosing complete alternatives
Preserve whole factual statements instead of cutting a caption through a number.
Tools: freeAny AIClear narrative slots before authoring
Prevent prefilled template text from bypassing a narrator that skips occupied blocks.
Tools: freeAny AIClamp scheduled sends to a local-time window
Enforce local sending hours in scheduling code and the worker, preserving valid requests and explaining adjustments.
Tools: freeAny AIChoose charts that explain the actual subject
Use charts for numerical arguments; remove irrelevant charts, decorative two-value bars, and empty chart frames.
Tools: freeAny AIRefresh chart assets before trusting screenshots
Distinguish a cached preview from the image currently stored at a reused URL.
Tools: freeAny AIKeep branding from overwriting authored content
Apply brand defaults after authoring and prove nonempty user content survives.
Tools: freeAny AIBound optional photo mirroring time
Keep an external image copy from leaving a build waiting indefinitely.
Tools: freeAny AIGate Email Intake on Authentication and Consent
Block unauthenticated submissions before download and restrict replies to the original sender.
Tools: freeAny AIWire stored secrets into the consuming runtime
Keep credentials out of tracked content and verify that the workflow actually receives its secret-store bindings.
Tools: freeAny AIConnect obligation intake to automatic completion
Require a completion signal or explicit exception, then run the draining sweep.
Tools: freeAny AIVerify private error reporting and alerts
Capture application errors across runtimes without exposing diagnostics or request bodies.
Tools: freeAny AIVerify a Private Deployment
Transfer only reviewed files, verify their integrity, and isolate credentials from public serving paths.
Tools: freeAny AIVerify a disabled service actually stops
Check live process command lines and persistent configuration after disabling a workload.
Tools: freeAny AIVerify Which Code Reaches Production
Trace deployments and inspect the production revision before accepting claims about live behavior.
Tools: freeAny AIVerify Orders Before Releasing Repaired EPUBs
Match paid orders to accepted diagnoses and issue private delivery with explicit expiry and renewal rules.
Tools: freeAny AIOffer Repairs Only After a Clean Validation
Gate repair offers on measurable improvements, prevent duplicate active quotes, and recognize free samples.
Tools: freeAny AIClose alerts with an auditable receipt
Assign alerts an owner, deadline, and closure evidence; keep pending items visible until disposition is recorded.
Tools: freeAny AIVerify assumption-change signals in primary documents
Separate documented contradictions from allegations and indirect indicators.
Tools: freeAny AITest local security during component outages
Disconnect dependencies separately and verify recording, visible faults, and bounded aircraft recovery.
Tools: freeAny AITest authorization with real unprivileged users
Probe ownership boundaries rather than counting policies or trusting privileged requests.
Tools: freeAny AIStop Launches When a Shared Quota Is Exhausted
Detect quota exhaustion, record recovery state, and suspend every session until the reported reset.
Tools: freeAny AIStage rate limits before enforcement
Observe legitimate traffic before enabling rejection at the outer rate-limit layer.
Tools: freeAny AIAudit a small app across infrastructure layers
Prioritize observed cost, exposure and recovery gaps using evidence from the actual application.
Tools: freeAny AISerialize publishers before loading authority
Prevent delayed publishers from replacing newer approved output or reviving revoked routes.
Tools: freeAny AICheck Producer Heartbeats on an Independent Schedule
Detect a silent producer without waiting for its next push.
Tools: freeAny AIDeploy Compatibility Before Renaming Configuration
Keep dependent requests working while configuration names change across code and deployment settings.
Tools: freeAny AISeparate user traffic from deployment probes
Verify that logged activity represents users before using it to justify caching work.
Tools: freeAny AIDispatch publication without rerunning collection
Let approval publish existing output without triggering unrelated source checks or notices.
Tools: freeAny AISelect one artifact across every result page
Keep artifact identity fields together when choosing a retained build from paginated results.
Tools: freeAny AISchedule Visible Control-Branch Tests
Run synthetic control tests weekly and surface failures through the normal operational reporting channel.
Tools: freeAny AIRun Smoke Tests Linked to Verification Records
Run concurrent HTTP assertions, stamp passing records, and expose failures and manual checks without closing them.
Tools: freeAny AIReview an SVG Package Before Delivery
Check visual fidelity and delivery records before releasing an SVG archive.
Tools: freeAny AIResume setup after secret synchronization fails
Retry external synchronization independently of local creation and declare readiness only after a live baseline.
Tools: freeAny AIResume batch work through persisted handoffs
Persist batch identifiers and input fingerprints before polling so later runs can collect safely.
Tools: freeAny AITest writes and sequences after restoration
A restored app must create, serve and remove new data without reusing previously issued IDs.
Tools: freeAny AIReserve API budget before making calls
Refuse spending when limits or accounting state cannot be trusted.
Tools: freeAny AIDistribute Channel Assets From One Report
Turn a sourced report into audience-specific assets and direct every drop to its live canonical page.
Tools: freeAny AIRecover Hosted Links After a Tunnel Restart
Recover the current hostname, verify hosted routes, and replace stale links and delivery references.
Tools: freeAny AIRebuild Dashboards From Current Inputs
Preserve current tracked topic dashboards, restore non-topic inputs, and rebuild the published site.
Tools: freeAny AIQueue Work Behind an Active Runner
Use a bounded detached waiter that retries the locked launch when capacity becomes available.
Tools: freeAny AIGate every publication on current approval
Keep observations separate from approved output and enforce current approval and authorization on every publishing path.
Tools: freeAny AIPublish and Verify Before Sending Notices
Build and deploy the change, verify its live page, then send notices and commit delivery state.
Tools: freeAny AIRun Private Intake With Preview and Safe Retries
Separate preview from sending, serialize processing, and retry failed replies without creating duplicate deliveries.
Tools: freePythonAny AIPackage a Scoped SVG Batch
Build a reviewable SVG archive while preserving originals and excluding private intake data.
Tools: freePythonAny AIDetect stale outputs beyond green schedules
Measure the age of produced data and separately prove scheduled execution occurs.
Tools: freeAny AIGate and order nightly data workflows
Require landed rows before publishing, then reject downstream sends with stale publication tokens.
Tools: freeAny AIMonitor Hosted Pages Through a Service Commitment
Check every required service and promised page daily through the agreed hosting period.
Tools: freeAny AIMigrate DNS Without Dropping Records
Inventory every DNS record before changing nameservers, then verify the imported set after migration.
Tools: freeAny AIMeasure actual traffic before adding a cache
Target the path users call instead of optimizing a merely existing endpoint.
Tools: freeAny AIRecord out-of-band actions without repeating them
Keep a ledger accurate when a person completes work outside the application.
Tools: freeAny AIPromote tasks to verification only after code lands
Keep an empty specification from masquerading as completed implementation.
Tools: freeAny AICheck the operations index before building a report
Avoid duplicating a monitor that already answers the question.
Tools: freeAny AICheck the work behind a parked workflow
Inspect concrete deliverables as well as a workflow's gate and trigger state.
Tools: freeAny AIAdd access barriers beyond row policies
Restrict network access and remove unused database grants before a policy change can expose them.
Tools: freeAny AIGuard Collectors Using Removable Archives
Stop capture when the intended archive volume is absent or storage safeguards fail.
Tools: freeAny AIWait for the Tested Commit to Be Deployed
Release smoke tests only when a ready production deployment matches the workflow's triggering commit.
Tools: freeAny AIGate rollback on critical smoke failures
Retry critical checks once before a guarded rollback; report soft failures without rolling back.
Tools: freeAny AIGate a One-Shot Scheduled Send
Limit a scheduled message to one request and reconcile uncertain delivery before claiming contact.
Tools: freeAny AIGate Catalog Promotion on a Clean Live Cycle
Keep a new data product provisional until its live pipeline, independent parity, and output checks pass.
Tools: freeAny AIGate supervised drone missions
Block launches and route changes unless authorization, fresh safety inputs, and recovery capacity pass.
Tools: freeAny AIAttach Evidence Atomically When Closing Checks
Evaluate stored signals before closure, require evidence for manual checks, and clear proof when reopening.
Tools: freeAny AIProve a backup restores in isolation
Restore a named archive, exercise it, record measured results and destroy the test environment.
Tools: freeAny AIBuild a Shared Cron Failure Classifier
Turn log tails into consistent classes and guarded suggestions without model calls.
Tools: freePythonAny AISeparate deploy rollback from data recovery
Write distinct recovery paths for application code, database changes and stored files.
Tools: freeAny AIDeploy Public Files to a Shared Subpath
Copy selected public assets into an assigned subdirectory, verify them, then publish its navigation link.
Tools: freeGitAny AIMeasure rates when judging a cumulative counter
Use interval deltas to decide whether a fix reduced ongoing usage.
Tools: freeAny AIAutomatically close verified obligations
Give an obligation ledger a scheduled closer that distinguishes completion from superficial matches.
Tools: freeAny AICheck account constraints before restarting
Separate the layer reporting an outage from quota or account restrictions that may keep causing it.
Tools: freeAny AIRetry Transient Cron Failures Once
Recover temporary failures while preventing retry loops and preserving stale-data alerts.
Tools: freeAny AIExecute a Bounded Data Repair
Establish authority, reject stale plans, change only the intended field, and verify outcomes separately.
Tools: freeAny AIBind changing claims to their source of truth
Replace maintained literals with derived values and block changes that leave authoritative records stale.
Tools: freeAny AIBench-test drone charging interlocks
Require safe seating and battery conditions, then inject faults with motors physically disabled.
Tools: freeAny AIArchive Obsolete Code Without Breaking Dependents
Move retired material out of active discovery while preserving files still required by imports, jobs, or checks.
Tools: freeAny AIArchive old obligations without losing their record
Reset an authorized backlog while retaining complete history and reversible dispositions.
Tools: freeAny AIResearch & knowledge
Knowledge management · Research workflows · Web research · Source discovery43 filesRecover an unfamiliar product from session records
Search prior transcripts before replacing an unknown name with a web-search guess.
Tools: freeAny AIRoute an AI to relevant notes on demand
Search a small keyword map and read the matching pages instead of preloading the whole wiki.
Tools: freeAny AIReview corrections without freezing observations
Detect meaningful changes under existing identifiers while retaining the approved display until review.
Tools: freeAny AISave reviews where the next session can find them
Make reviews durable artifacts instead of leaving them inside one conversation.
Tools: freeAny AIKeep immutable sources beside a maintained wiki
Compile linked notes while preserving raw evidence and explicit supersession.
Tools: freeAny AICount document reachability without self-credit
Exclude generated inventories from evidence that documents are meaningfully discoverable.
Tools: freeAny AISeparate quoted and proxy options backtests
Use covered bid/ask quotes and label uncovered pricing proxies without duplicating spread costs.
Tools: freeAny AIValidate API filters before trusting absence
Check that a filter narrows results before treating an empty result as evidence.
Tools: freeAny AIScreen Concentrated Citation Bursts
Combine short citation spans with country concentration to catch artifacts missed by entity diversity.
Tools: freeAny AIScore candidate sources by outcomes
Label candidates before scoring, compare settled outcomes consistently, and base source status changes on recorded evidence.
Tools: freeAny AIScore Backtests by Market Regime
Expose regime-dependent failures that aggregate backtest results can conceal.
Tools: freeAny AIKeep the countercase in the linked artifact
Preserve each candidate's adversarial reasoning where the decision record actually points.
Tools: freeAny AIMake annualization frequency explicit
Require periods per year and inspect existing library behavior before annualizing a statistic.
Tools: freeAny AIReport walk-forward efficiency with sample size
Show efficiency alongside out-of-sample trade count without inventing an unsupported acceptance threshold.
Tools: freeAny AIRepair feature warmup in walk-forward tests
Precompute causal features when short test slices prevent out-of-sample trades.
Tools: freeAny AIMeasure Repair Coverage in a Lab and Pilot
Test controlled failures first, then measure supported repairs on authorized real incidents.
Tools: freeAny AICount parameter trials that produced no trades
Preserve every tested parameter cell while keeping undefined results out of dispersion calculations.
Tools: freeAny AIProduce a Novel, Actionable Research Digest
Compare ideas against existing records and retain only findings with a concrete consequence.
Tools: freeAny AIPackage research for an AI follow-up
Export the accepted brief, traceable evidence, unresolved questions, and an editable follow-up as a portable snapshot.
Tools: freeAny AIIsolate Exploratory Arms from Registered Comparisons
Keep a new experiment's data and state separate while preserving explicit comparator inputs.
Tools: freeAny AIBuild Point-in-Time Historical Prediction Grades
Generate internal calibration data only from series that can be reconstructed without look-ahead.
Tools: freeAny AIFreeze a Universe with a Venue Liveness Screen
Remove duplicate numeraires and structurally favored pegged assets, then freeze venue-active candidates.
Tools: freeAny AIEvaluate Added Features Against a Seasonal Baseline
Test whether extra domains improve a forecast using an untouched chronological holdout.
Tools: freeAny AIChoose a graph by content and revision coverage
Distinguish code indexes, documentary graphs, and diagrams before querying them.
Tools: freeAny AIDefine a Forecast That Can Be Scored
Freeze the future outcome, input cutoff, release policy, and grading rules before forecasting.
Tools: freeAny AIKeep a journal of process and outcome
Record assumptions before a decision and review its reasoning separately from what happened.
Tools: freeAny AICompare Cross-Domain History with Matched Periods
Compare each series against its own equivalent period while preserving geography and coverage.
Tools: freeAny AIClassify Tier Divergence Deterministically
Combine spread and lower-tier changes while preventing upper-tier growth from overriding weakness.
Tools: freeAny AIAuthor an Evaluable Scenario Task
Build a product-research task with separate scenario, persona sampling, verification, and reporting inputs.
Tools: freeAny AIBound Simulation Claims by Feed and Venue Depth
Expose historical-feed limits and simulated fills that exceed the activity represented by that feed.
Tools: freeAny AIAudit a backtest before reporting results
Check trades, costs, bias, validation, and run provenance before treating results as evidence.
Tools: freeAny AIAdd a project-fit column to research findings
Show which measured problem each candidate addresses, or explicitly record no fit.
Tools: freeAny AIDetect search failures behind empty results
Record answering engines and response validity before treating no results as no evidence.
Tools: freeAny AIRun private metasearch with a JSON interface
Configure a local search service, keep it private and prove real JSON responses before wiring agents.
Tools: freeAny AIChoose HTML extraction or a JSON API
Inspect the real response and use a typed API when it supplies the required records.
Tools: freeAny AISpace Crawls to Avoid False Outage Reports
Pace requests to each host before treating burst-induced timeouts as source downtime.
Tools: freeAny AIDiagnose an empty scrape before giving up
Inspect status, content and the fetch path before labeling the whole site inaccessible.
Tools: freeAny AIKeep child processes from eating a shell loop
Give each crawler its own stdin so the parent loop processes every input record.
Tools: freeAny AICompare search tools by citation fidelity
Choose grounded retrieval by inspectable claim citations rather than apparent answer quality.
Tools: freeAny AIChoose polling cadence from source changes
Match refresh frequency and cache expiry to verified publication behavior.
Tools: freeAny AIQualify a Data Source Before Adopting It
Bound access probes and establish meaning, coverage, timing, operating cost, and permitted use.
Tools: freeAny AIPoll Listings With Control Gates
Detect new candidates while keeping failed polls from corrupting state or producing misleading silence.
Tools: freeAny AIEvaluate an archive source before outreach
Assess public activity, ownership and contactability without collecting the archive itself.
Tools: freeAny AIPractical reference
Website building30 filesDurable TypeScript workflows with the Workflow SDK
Builds durable TypeScript workflows with automatic retries, state persistence, resource-free sleeping, and human-in-the-loop approval hooks.
Tools: freeNodevercel accountn8n pipeline into Supabase storage and tables
Builds an n8n workflow to generate social media content and images using OpenAI, saving assets to Supabase.
Tools: freen8n accountsupabase accountNative CSS replacements for common JavaScript UI features
Implement scroll offsets, snapping, form validation styles, focus rings, and auto-growing textareas using pure CSS instead of JavaScript.
Tools: freeAny AIAssemblyAI dictation and voice agents
Integrates speech-to-text, dictation, and voice agents into applications using AssemblyAI APIs.
Tools: paidGitNodeCSS-only details and summary animation
Animate HTML details disclosure elements and staggered child content using modern CSS transitions and starting-style rules.
Tools: freeAny AICSS text-box-trim and text-box-edge
Trims internal font whitespace to achieve exact, consistent spacing and alignment in web layouts.
Tools: freeAny AILocal-first Next.js and Supabase with Claude Code
Set up a local-first Next.js and Supabase development workflow using Claude Code and Agent Skills.
Tools: freeNodeDockerNext.js VPS deployment with Claude Code
Deploys a Next.js application to an Ubuntu VPS using Docker, GitHub Actions CI/CD, Caddy, and Cloudflare.
Tools: paidSSH accessDockerSupabase pgvector setup
Enable the pgvector extension in Supabase and create a table with an embedding column for semantic and hybrid search.
Tools: freesupabase accountAny AICSS sibling-index and sibling-count functions
Animate and stack sibling elements dynamically without manual nth-child rules or JavaScript.
Tools: freeAny AISupabase Row Level Security and roles
Implement multi-tenancy, role-based access control, Row Level Security policies, and custom JWT claims in Supabase and PostgreSQL.
Tools: freesupabase accountAny AISupabase row-level security for anonymous users
Restrict each task to its anonymous owner using database RLS, shared sessions, and per-user foreign keys.
Tools: freeNodeDockerArcjet API endpoint protection for AI apps
Limits AI API usage and blocks bots, attacks, and sensitive data before costly model calls.
Tools: paidNodeOpenAI API keyAntigravity AI scroll-animation website workflow
Generate product visuals, convert video frames, and build a polished mouse-scroll website with AI.
Tools: paidAny AIStripe subscription sync pattern
Build reliable Stripe subscriptions with webhook-triggered pulls, local caching, checkout metadata, and server-side verification.
Tools: freeNodestripe accountSupabase Auth authentication and row-level security
Authenticate users with Supabase and authorize database rows using JWT-based row-level security policies.
Tools: freeAny AIOWASP Top 10 2025 review checklist
Walk an application through the ten 2025 OWASP risk categories with a check and a mitigation for each.
Tools: freeAny AISupabase Edge Functions CLI guide
Create, test, deploy, invoke, package, and secure Supabase Edge Functions using TypeScript and Deno.
Tools: freesupabase-cliDockerVercel Fluid compute for Functions
Turn on Fluid compute for Vercel Functions so one instance serves concurrent requests, then check billing and shared state.
Tools: freevercel accountAny AIReact Scan render profiler
Finds excessive React renders and the components causing performance slowdowns.
Tools: freeNodeAny AIUI design heuristics for AI development
Improve AI-generated user interfaces by eliminating visual clutter, fixing visual hierarchy, and avoiding default styling patterns.
Tools: freeNodeAny AIWeb accessibility auditing and HTML remediation
Detect and resolve web accessibility issues including landmarks, headings, alt text, contrast ratios, and keyboard navigation.
Tools: freeAny AILanding page hero section design framework
Structure landing page copy and select matching key visuals to improve visitor comprehension and conversion.
Tools: freeAny AIAura AI UI design editor
Generate and customize web UI layouts from reference screenshots without manual styling or repetitive code changes.
Tools: freeAny AIClaude Design web design workflow
Build and iterate on web landing pages and custom design systems using Claude Design and visual references.
Tools: freeAny AIModern CSS layout patterns and features
Build responsive scrollers, adaptive auto-grids, container query components, and scroll animations using pure CSS.
Tools: freeAny AICSS spacing and typography layout
Configures vertical rhythm, flow spacing, container padding, grid gaps, and text trimming across web components.
Tools: freeAny AITaking the generic look out of AI web design
Eliminate generic AI aesthetics from generated landing pages using structured design systems, reference screenshots, and custom assets.
Tools: freeNodeAny AIChrome DevTools Performance panel
Diagnose web performance bottlenecks, replicate real-world user conditions, and test fixes directly within Chrome DevTools.
Tools: freeAny AIBuild a custom site with Claude Code and ship it
Install two front-end design skills, prompt for a site with animations, polish it in batches, then zip it and upload it to a host.
Tools: paidNodeClaude CodeMonitor a source and explain what changed
Build a baseline, detect meaningful changes, and produce an updated dashboard with an alert decision.
Tools: freeGive an AI a usable project memory
Compile supplied documents into a source-linked wiki and retrieve the right evidence for a question.
Tools: freeBring a source into an AI data product
Implement ingestion whose records survive bad refreshes and are actually queryable by the intended AI consumer.
Tools: freeProduce reports whose claims trace to data
Generate a report or chart-backed answer using computed facts and auditable relationships.
Tools: freeBuild consistent branded emails
Turn approved content into a branded email preview with checked layout, links and factual content.
Tools: freeMake an AI coding change with working checks
Map a requested change, implement its controls and prove the actual user path handles the target failure.
Tools: freeProve an application can recover
Produce a recovery runbook backed by an isolated restoration and successful application writes.
Tools: freeRepair a listing value without losing the correction
Prepare and execute a scoped repair, verify the rendered result, and prove it survives upstream synchronization.
Tools: freePublish exactly the content that was approved
Build a publication workflow in which corrections remain reviewable and delayed publishers cannot restore obsolete or revoked content.
Tools: freeAudit historical experiments without hiding failed trials
Produce an experiment audit that preserves every trial and tests whether historical signals used only available information.
Tools: freeRetrieve evidence and diagnose empty results
Choose a suitable retrieval route and distinguish missing evidence from broken extraction or ignored filters.
Tools: freeKnow whether an automated job really worked
Instrument an existing job so missed runs, invalid output, resource problems and unresolved alerts are visible separately.
Tools: freeNo matching briefs.
Try fewer filters or request a topic.