AI Hot Source

Fully open-source weights; free unlimited self-hosted image-to-3D

Best free image-to-3D quality in 2026 reviews; custom self-hosted pipelines (e.g. a DTR-style reconstruction backend) with PBR-material output

⚠ Image-only (no text-to-3D); needs a Linux box with ~24GB NVIDIA GPU, so rent a GPU or use a hosted wrapper. Static meshes only — no rigging/animation. Verify the exact TRELLIS 2 repo name on Microsoft's GitHub; third-party 'trellis2' sites are wrappers, not canonical.

Hunyuan3D 2.x open weights free to self-host; v3 is hosted/API

Top open-source TRELLIS alternative; text-to-3D as well as image-to-3D, strong texture quality

⚠ Tencent community license is not OSI and historically excludes use in the EU/UK/South Korea — read the license before using from London; that may rule it out commercially. v3 (highest quality) is hosted-only, which also trips the avoid-hosted-Chinese-services rule.

~100 credits/month free; full pipeline incl. text/image-to-3D, texturing, auto-rig, animation presets

Fastest no-GPU path from concept to rigged, animated, engine-ready asset; good for prototyping game/web assets

⚠ Free-plan assets are CC BY 4.0 — public, attribution required, and NOT retroactively re-licensed if you upgrade later; generate anything commercial on a paid plan. Low queue priority, polycount capped (~10k) on free.

Open weights under Stability Community License — free including commercial use below ~$1M annual revenue

Sub-second single-image-to-mesh on a modest GPU; bulk/low-latency asset generation where speed beats fidelity

⚠ Quality clearly below TRELLIS 2/Hunyuan3D for hero assets — it's a speed play. Licence-threshold detail is from pre-2026 knowledge; re-check Stability's current community licence terms. Single-source claim, not re-verified this pass.

Apache 2.0 open weights; free unlimited self-hosted text/image-to-video

Highest-quality open video model benchmarked in 2026 (prompt adherence 8.4, motion 8.7); the default open choice when quality matters

⚠ Wants a 24GB card (4090/3090/A6000) — not Latitude-iGPU territory; budget ~4min per 5s clip even on a 4090. Open weights sidestep the hosted-Chinese-service concern but verify the licence on the specific 2.x checkpoint you pull.

Open weights, free self-hosted; near-real-time generation

Fast iteration; the only open video model that fits comfortably on a 12–16GB GPU; first-class ComfyUI nodes

⚠ Quality a tier below Wan 2.2/HunyuanVideo (2026 benchmark ~7.6 vs 8.4 prompt adherence). Uses Lightricks' own openrail-style licence, not plain Apache — check commercial terms for your use.

Roughly 30 generations/month free (slower queue)

Most generous hosted free tier among Runway/Kling/Pika/Luma in 2026 comparisons; great camera controls; fits the Singularity-shots vid2vid restyle lane

⚠ Sources conflict on whether free output is watermarked (one 2026 review says no watermark, another says watermarked) and free tier is non-commercial — verify in-app before shipping anything. Runway is down to a one-time 125-credit trial; Kling free is a trickle of daily credits.

Free (incl. commercial) for individuals, non-profits, and for-profit companies up to 3 employees; source available

Programmatic video in React — the proven editor lane on this machine (wand-combat reel, singularity-shots); pairs with AI gen for cuts-as-data pipelines

⚠ Not OSI open source — company licence required once a for-profit org passes 3 employees, and licence terms shift slightly in Remotion 5.0. Rendering needs headless Chrome; GPU-light but CPU-hungry.

Apache 2.0, 82M params — free unlimited, runs on CPU and even in-browser (Kokoro Web)

Zero-cost production TTS for pipelines (audiobook/librarian profile, shortform videos); permissive licence means commercial output is clean

⚠ Fixed voice set, no voice cloning, English-leaning quality; for character voices or cloning you still need ElevenLabs/openvoice-class tools. Quality is 'very good', not ElevenLabs-flagship.

whisper-large-v3 and v3-turbo free at 20 req/min, 2,000 req/day, 7,200 audio-seconds/hour; no credit card

Fast free transcription backbone — already powering voice-ptt and audio-tray; ~2h of audio per clock-hour is plenty for personal pipelines

⚠ Rate limits (429s) make it wrong for big batch jobs — Groq's paid Batch API is the volume path. Limits are per-account and Groq has tightened tiers before; re-check console.groq.com/settings/limits. (Local note: the model-pool memo says the current Groq key is dead — mint a new one.)

~10,000 credits/month free TTS; affiliate program pays commission on referred subscriptions

Best-in-class voice quality and cloning for demos; the affiliate program is a real money lane given existing insider contacts via Riffraff

⚠ Free tier is NON-commercial and requires attribution — commercial licence starts at the paid Starter tier, so don't ship free-tier audio in Riffraff prod. Affiliate commission rate (~22% first-year historically) not re-verified this pass — confirm current terms on their affiliate page.

Free interactive use of Gemini image models (Nano Banana / Gemini Flash Image) in AI Studio and the Gemini app; text-model API has a free tier

Best free image generation quality in 2026 roundups; matches the existing 'prefer Gemini for image pipelines' eval

⚠ API-side image generation free tier is disputed: at least one Jan-2026 source says Google's image-gen API routes now show 'Free Tier: Not available' after the old free preview was shut down Nov 14 2025 — assume UI-free/API-paid until you verify in AI Studio. Free-tier prompts may be used for training.

FLUX.1 [schnell] is Apache 2.0 (free incl. commercial); FLUX.2 [dev] open weights free to self-host, up to 4MP

Self-hosted image gen with no per-image cost; schnell for clean-licence commercial assets, FLUX.2 dev for top open-weights quality

⚠ FLUX [dev] variants use a non-commercial licence — commercial use of dev outputs needs a BFL licence; only schnell is unambiguously commercial-safe. FLUX.2 dev is heavy; expect to need a rented GPU rather than the iGPU.

Open-source music foundation model; free unlimited local generation, runs on consumer hardware

The 2026 consensus 'true Suno alternative' — full songs with vocals + lyrics, fast, LoRA fine-tuning; soundtrack lane for Riffraff/shortform/games

⚠ v1 was Apache 2.0; confirm 1.5's licence and training-data provenance before commercial release of tracks. Vocal realism still below Suno's latest hosted models. Alternatives if it disappoints: YuE, DiffRhythm.

Free to enter; cash-prize hackathons (AI-sponsored ones regularly $5k–$100k+ pools)

Converting existing portfolio pieces (DTR pipeline, Riffraff, Resource Atlas) into prize entries — hackathon-hunter already scrapes its board

⚠ Judging is slow and lottery-like; read eligibility per-hackathon (some US-only — check UK eligibility before building). Sponsor hackathons often require using the sponsor's API, which can mean burning a weekend on lock-in tech. Never auto-submit (existing rule).

Free for contributors — browse and claim paid GitHub bounties ($100–$4,000 observed); pay-on-merge

Direct cash for OSS PRs in public repos; doubles as a hiring funnel (paid trials → contracts) which fits the job-search lane

⚠ Competition on juicy bounties is real — others may race you to the merge; payment only on merged work, so scope before investing. Org side pays a 9% fee (contributor side effectively net of processing). Platform itself is AGPL-3.0 open source.

No subscription cost — merchant-of-record takes a per-transaction cut (smaller than Patreon's 8–12%; ~4% + fixed fee class)

Monetising side projects fast: sell licences/digital products, subscriptions, and fund GitHub issues without forming payment infrastructure; MoR handles VAT — relevant for a UK Ltd

⚠ Exact current fee schedule not re-verified this pass (historically ~4% + 40¢) — check before pricing. MoR means Polar is the seller of record: less invoicing pain, but their ToS governs what you can sell. Open-source platform, Stripe payouts.

Free tier, no card: ~30 RPM / 6,000 TPM / 1,000 requests-day on most models (small 8B models up to 14,400 RPD; Llama 4 Scout has 30K TPM; Llama 4 Maverick halved to 15 RPM / 500 RPD). Whisper large-v3 / v3-turbo: 20 RPM, 2,000 requests/day, 7,200 audio-seconds/hour, 25MB upload cap. Limits are per key per model; reset midnight UTC.

Speed-critical text and tool-calling (LPU hardware, 3-10x faster than GPU providers) and free Whisper transcription pipelines. OpenAI-compatible endpoint.

⚠ 6K TPM is the binding constraint for long prompts, not the daily cap. You hit whichever limit (RPM/TPM/RPD) arrives first — read x-ratelimit-* headers and back off. Keys get revoked/dead occasionally; rotate and re-verify. Batch workloads outgrow it fast.

No card, no expiry. Post-Dec-2025 quota cuts: Gemini 2.5 Flash-Lite ~15 RPM / 1,000 RPD; Flash ~10 RPM / 250 RPD; Pro ~5 RPM / 50-100 RPD; ~250K TPM across models. Multimodal (vision/audio input) and gemini-embedding included in free quota. Limits per project, reset midnight Pacific.

Highest-quality free model access, long context (1M tokens), free vision/multimodal calls, and free embeddings — the volume workhorse of a free-provider stack.

⚠ Free-tier prompts may be used to improve Google products — don't send sensitive data. Sources conflict on exact RPD (some still quote pre-cut 1,500 RPD for Flash; ~250 is the safer planning number as of early 2026 — verify in your console). Quotas have been volatile; undocumented stricter limits on image generation.

1,000,000 tokens/day free, no card, no waitlist. ~30 RPM, 60K-100K TPM depending on model. Llama, Qwen, GPT-OSS-120B, GLM families. OpenAI-compatible. Daily reset, no rollover.

Token-hungry batch jobs (classification, generation pipelines, daily reports) and anything latency-sensitive — wafer-scale hardware pushes 1,000-3,000 tokens/sec.

⚠ Free tier context window capped at 8,192 tokens across all models ('temporary', up to 128K on request) — kills long-context use cases. Preview models have much tighter caps (e.g. GLM 4.7 at 10 RPM / 100 RPD). Model lineup rotates.

Models with ':free' suffix: 20 RPM; 50 requests/day with <$10 lifetime credits purchased, 1,000 requests/day once you've topped up $10 (one-time, the $10 stays spendable). Dozens of free models — DeepSeek R1/V3, Llama, Gemini Flash variants, etc.

Trying many models behind one OpenAI-compatible key; fallback routing when a primary free provider 429s. The $10 unlock is the best $10 in free inference.

⚠ Free variants are served by third-party providers (e.g. Chutes) that throttle free traffic to favour their own paying users — 429s are common at peak and aren't OpenRouter's doing. Free model lineup churns weekly. Provider data policies vary — check the model page before sending anything private. Negative balance = 402 even on free models. Multiple accounts don't help (global limits).

Free trial with no time limit: the old 1,000-5,000 credit system was replaced by per-model rate limits (~40 RPM typical, shown top-right of build.nvidia.com; not published per model). Hosts Nemotron, Llama, Mistral, Microsoft and other open models. OpenAI-compatible.

Free access to big open models (e.g. Nemotron-3-Super-120B) for prototyping, research, and agent backends without self-hosting.

⚠ Licensed for trial/dev/test only — production use formally requires an NVIDIA AI Enterprise license. Rate-limit increases need a forum request (40→200 RPM requests routinely sit unanswered). Older accounts may still show the legacy credit system; personal-email signups got fewer credits. Limits unpublished, so budget conservatively.

Experiment plan: $0, no card (phone verification required). Per-model limits: ~1 req/sec, 500K tokens/min, 1B tokens/month — and limits are per model, so multiple models multiply your quota. Includes proprietary models (Mistral Large/Medium, Codestral, Pixtral) plus mistral-embed.

Huge free token volume for prototyping; free Codestral for code completion; an EU-jurisdiction provider if data residency matters.

⚠ Free tier requires opting in to data training — your prompts train their models. Explicitly for evaluation/prototyping, not production. 1 RPS concurrency is the real constraint for agent loops, not the monthly token cap.

Free with any GitHub account: OpenAI GPT-4.1/o-series, Llama, Phi, Mistral, DeepSeek etc. via one GitHub PAT. Per-model tiered limits (roughly: 'low' tier ~15 RPM / 150 RPD, 'high' tier ~10 RPM / 50 RPD, reasoning models single-digit RPD) with small context/output caps (~8K in / 4K-8K out on free).

Zero-signup model comparison and CI/Actions-integrated LLM calls using credentials you already have.

⚠ Rate limit numbers above are from documented 2025 tiers — GitHub has been folding this into Copilot premium-request billing, so re-verify current per-model RPDs (uncertain as of June 2026). Token windows are clipped versus the same model elsewhere. 403s can come from org policy or region blocks, not quota. Not for production.

10,000 'neurons'/day free, no card, on Workers Free. Catalog of 50+ open models: Llama 3.x, Gemma, Mistral, Stable Diffusion XL (image gen), BGE embeddings, Whisper STT. Runs on Cloudflare's 300+ edge locations; OpenAI-compatible via AI Gateway.

Edge-latency inference inside Workers apps, and the rare free tier that covers text + embeddings + image generation + speech-to-text under one quota.

⚠ 'Neurons' are an opaque compute unit — per-model neuron cost is hard to find, so the 10K/day budget is unpredictable until you measure it. Models are small/open-weight only — no frontier quality. 10K neurons is only a few hundred LLM responses in practice.

Free accounts get a small monthly credit bucket (~$0.10/month) routed through the HF router to Groq, Together, Fireworks, Hyperbolic, Cerebras etc. PRO ($9/mo) gets ~$2/month included credits (20x) plus ZeroGPU. No markup over provider rates.

One key + one SDK over many providers; quick smoke tests of any Hub model; BYO provider keys routed through HF for unified billing.

⚠ The free $0.10/month is exhausted in a handful of calls — it's a taster, not an inference budget. No pay-as-you-go on free accounts (hard stop at the cap). Error messages name the downstream provider (e.g. 'limit for groq'), which confuses people into thinking it's a provider-side ban.

Free trial API keys, no card: historically ~20 RPM and ~1,000 calls/month covering Chat, Embed (embed-v4), Rerank, and Classify endpoints.

Free reranking — Cohere Rerank is the standout free citizen here for RAG pipelines — plus solid multilingual embeddings at prototype volume.

⚠ Exact 2026 trial quotas unverified — Cohere has tweaked trial limits several times; confirm in the dashboard before building on them. Trial keys are for evaluation only; production requires a paid key. Trial traffic may be used for model improvement.

Free API key on signup with a one-time token grant (historically ~1M tokens, promotional grants up to 10M) covering jina-embeddings-v3/v4, reranker, and the Reader API (r.jina.ai URL-to-markdown, generous free rate without a key).

Free long-context multilingual embeddings and the Reader API — the easiest free way to turn web pages into clean LLM-ready markdown.

⚠ Token grant is one-time, not monthly — it runs out silently. Exact grant size as of mid-2026 unverified; check the dashboard. Reader API rate limits tightened over time for keyless use.

Free token grant on signup — historically 200M free tokens on most models (50M on some premium ones), which is enormous for embeddings. voyage-3.5 family + rerankers.

Embedding a large corpus once for free — 200M tokens covers most personal/startup RAG indexes end-to-end. Top-tier retrieval quality.

⚠ Grant size/terms as of June 2026 unverified (MongoDB acquired Voyage in 2025 — free tier may have shifted under MongoDB billing); confirm before relying on it. One-time grant, not recurring. Low default RPM until you add a card.

Fully free, open source, unlimited — bounded only by your hardware. One-line model pulls (Llama 3.x, Qwen, DeepSeek-R1 distills, Gemma, Phi, embeddings like nomic-embed/BGE), OpenAI-compatible local server on :11434.

Default local backend for agents, bulk/recurring jobs, and private data — zero marginal cost, no rate limits, works offline. Easiest local on-ramp.

⚠ Quality ceiling is your RAM/VRAM — 32GB laptop ≈ 7B-14B models at useful speed (CPU/iGPU inference is several tokens/sec, not Groq-fast). Quantization (Q4 etc.) trades quality for fit. Ollama's cloud/web-search add-ons are NOT free — local-only is the free path.

Free, MIT-licensed. Runs any GGUF model on CPU, CUDA, Metal, Vulkan, SYCL/oneAPI (Intel iGPU/NPU paths). llama-server gives an OpenAI-compatible endpoint; also does embeddings, speculative decoding, grammar-constrained output.

Maximum control and best performance-per-watt on non-NVIDIA hardware (e.g. Intel Meteor Lake iGPU via Vulkan/SYCL); the engine underneath Ollama/LM Studio when you need flags they don't expose.

⚠ DIY ergonomics: you compile flags, pick quants, and tune context/offload yourself. Build options (Vulkan vs SYCL) materially change speed on iGPUs — benchmark both. Moves fast; pin a release for anything durable.

Free for personal AND work use (license relaxed 2024). GUI model browser/downloader for GGUF + MLX, chat UI, and a local OpenAI-compatible server with per-model load/offload controls.

Friendliest way to discover, download, and A/B local models before promoting one into a headless Ollama/llama.cpp deployment; good for demoing local AI to non-technical people.

⚠ Closed source (free ≠ open). Heavier than headless llama.cpp — not what you want running as a daemon. Hardware ceiling caveats same as all local inference.

Fully free, open source, unlimited local speech-to-text. whisper.cpp (GGML, CPU/iGPU-friendly) and faster-whisper (CTranslate2, ~4x realtime on CPU with int8) run Whisper large-v3/turbo and distil-whisper locally.

Private or bulk transcription with no per-minute API cost and no 25MB upload caps — podcasts, meeting archives, voice pipelines that must work offline.

⚠ Slower than Groq-hosted Whisper (seconds-to-minutes vs near-instant) — use hosted for interactive, local for batch/private. Accuracy on accents/noise depends on model size; large-v3 needs ~3-4GB RAM quantized. Diarization needs a separate tool (e.g. pyannote).

Fully free, Apache-2.0 OSS from Microsoft. Run via `npx @playwright/mcp@latest`.

Letting agents drive a real browser via the accessibility tree (snapshot-based, no vision model needed) — form filling, UI verification, scraping behind JS.

⚠ Accessibility snapshots get huge on complex pages and eat context. Headed mode needs a display server; use headless in CI. Not built for parallel multi-session scraping at scale.

Fully free, MIT OSS (Anthropic reference servers repo, also includes Memory, Fetch, Sequential Thinking).

Granting non-CLI MCP clients (Claude Desktop, custom agents) scoped read/write access to specific directories.

⚠ Redundant inside Claude Code/Cursor which have native file tools. Directory allowlist is your only guardrail — scope it tight; a prompt-injected agent with write access is a real risk.

OSS server is free; the hosted remote MCP endpoint is free with any GitHub account. API usage bound by normal GitHub rate limits.

Agent-driven repo ops: issues, PRs, reviews, code search, Actions status — without shelling out to `gh`.

⚠ PAT scope = blast radius; use fine-grained tokens. Large toolset can bloat agent context — enable only needed toolsets. The `gh` CLI covers much of this with less setup if you already run in a terminal.

1,000 API credits/month free, no card required (verified June 2026). Search + extract endpoints included.

LLM-ready web search and page extraction for research agents and RAG — returns clean structured text, not raw HTML.

⚠ Advanced search depth costs 2 credits per call, so the 1k/month budget halves. Free tier capped at ~2 req/sec and basic depth on some plans — fine for personal agents, tight for fleets.

MCP server is free OSS; Supabase free tier gives 2 projects, 500MB Postgres, 50k MAU auth, edge functions.

Agents that need durable structured memory or app state — query/migrate Postgres, manage tables, generate types conversationally.

⚠ Free-tier projects pause after ~1 week of inactivity (agents then hit dead endpoints). Treat DB results as untrusted input — SQL-returned text is a prompt-injection vector. Prefer read-only mode + PAT scoping.

Free for personal use via hosted MCP; OSS server on GitHub (Upstash). API key optional for higher limits.

Injecting current, version-correct library docs into coding agents — kills the 'trained on v2, you're on v5' hallucination class.

⚠ Coverage skews to popular JS/Python libraries; niche or private libs absent. Doc dumps can be large — ask for specific topics, not whole libraries.

Fully free, Apache-2.0 OSS from Google.

Giving agents real DevTools access — console, network traces, performance profiling, CPU/network throttling — for debugging live pages rather than just driving them.

⚠ Debugging-focused; for plain navigation/interaction Playwright MCP is leaner. Attaching to your daily Chrome profile exposes logged-in sessions to the agent — use a separate profile.

SDK itself free (Python/TypeScript). Runs on Claude API (paid per token) or rides an existing Claude subscription via the CLI harness.

Production agents that want Claude Code's loop for free: built-in tool harness (file ops, bash, web), MCP client support, subagents, hooks, permissioning.

⚠ Anthropic-only — no model portability, so it's lock-in by design. Token costs compound fast in long agentic loops; budget and cap turns. Versions move quickly; pin them.

MIT OSS library, fully free self-hosted. LangSmith observability has a free dev tier (5k traces/month); LangGraph Platform is the paid hosted option.

Production multi-agent systems needing explicit state machines: graphs, checkpointing, human-in-the-loop interrupts, durable execution, time travel.

⚠ Steepest learning curve of the major frameworks — you hand-build the graph. Easy to drift into paid LangSmith/Platform for observability and deployment; self-hosting those pieces is on you.

MIT OSS framework, free self-hosted. CrewAI AMP (hosted platform) is paid with a limited free trial.

Role-based multi-agent teams (researcher/writer/reviewer patterns) with low boilerplate — fastest path from idea to working crew.

⚠ Abstractions hide the loop; debugging why an agent went sideways is harder than in LangGraph. Sequential crews can burn many LLM calls per task — watch token spend. Push toward the paid platform is increasingly visible in docs.

Apache-2.0 OSS, fully free. Model-agnostic: pairs well with free/local inference (Ollama, HF Inference free tier, Groq).

Minimal code-first agents — the agent writes Python instead of JSON tool calls, which benchmarks well with small/local models. ~1k lines of core logic, easy to read fully.

⚠ CodeAgent executes generated Python — sandbox it (it ships E2B/Docker executor options; the default local executor is only lightly restricted). Thin on memory/state management; you bring your own for long-running agents.

MIT OSS, free self-hosted (Docker). You pay only for LLM tokens; OpenHands Cloud is paid after intro credits.

Autonomous end-to-end software tasks — clone repo, edit, run tests, browse docs, open PRs — with a sandboxed runtime per session. Strong SWE-bench lineage.

⚠ Token-hungry: long autonomous runs on frontier models get expensive; cheap models degrade results sharply. Runtime sandbox is Docker-based — keep it off sensitive host mounts. Single-task focus, not a multi-agent orchestrator.

MIT OSS Python library, free self-hosted on Playwright/CDP. Browser Use Cloud is the paid hosted version.

Goal-directed autonomous web tasks ('find X and book Y') where the LLM plans multi-step navigation itself, vs. scripted Playwright steps.

⚠ Reliability is model-dependent and sites with heavy anti-bot measures still break it. Cost per task can be high (many vision/DOM-parse LLM calls). Fast-moving API — pin versions. For deterministic flows, plain Playwright is cheaper and more reliable.

Docker Engine and Podman fully free OSS on Linux (Docker Desktop free only for small orgs). Zero marginal cost per sandbox.

Default local isolation tier for agent code execution and devcontainers — disposable, offline, no per-second billing, full control of mounts/network.

⚠ Containers share the host kernel — weaker isolation than microVMs (E2B/Firecracker); add gVisor or run rootless for untrusted code. You manage lifecycle, image bloat, and resource caps yourself — no managed API.

Hobby plan: one-time $100 usage credit, up to 20 concurrent sandboxes, 1-hour sessions, 10GiB storage (verified June 2026 — note this is one-time credit, not monthly; some third-party sources claim 100 GB-hours/month, so confirm on e2b.dev before relying on it).

Firecracker-microVM code execution for agents — ~150ms cold start, real kernel isolation, SDKs designed for LLM tool-use loops. The standard pick for running untrusted AI-generated code.

⚠ Free credit is exhaustible, then pure usage billing — runaway agent loops can drain it. Cloud-only (your code runs on their infra). Sessions on Hobby cap at 1 hour.

Included usage allotment on the free Hobby plan, billed beyond it as active CPU time (uncertainty: exact Hobby allotment changes — check current docs before depending on it).

Ephemeral Firecracker microVMs for agent/code-gen execution when you're already on Vercel — same auth, billing, and SDK as the rest of the stack; sessions up to ~45 min.

⚠ Tied to the Vercel ecosystem; less standalone than E2B. Newer product with a thinner template/snapshot story. Hobby-plan limits are modest — fine for prototypes, not agent fleets.

Self-hosted Community Edition free with unlimited workflows/executions. NOT OSI open source — fair-code 'Sustainable Use License' (no reselling it as a service).

Visual glue layer around agents: 400+ integrations, webhook triggers, native AI/LangChain agent nodes, human-approval steps — the fastest way to wire agents into email/Slack/CRMs.

⚠ License bars offering n8n itself as a hosted product. Some features (SSO, env-based deploys, log streaming) are enterprise-gated even self-hosted. Heavy AI workflows in the visual editor get spaghetti-ish — keep complex logic in code nodes.

MIT OSS, fully free self-hosted (server + SDKs). Temporal Cloud is paid with intro credits.

Durable, crash-proof long-running agent workflows — retries, timeouts, signals, replayable history. Right tool when an agent pipeline must survive process death mid-run.

⚠ Real ops burden self-hosted: server cluster + Postgres/Cassandra + workers. Deterministic-workflow constraints take learning (LLM calls must live in activities, not workflow code). Overkill for simple cron-style agent jobs.

Self-hosted Community Edition free with unlimited executions (verified 2026); cloud free tier ~1,000 executions/day. Core is AGPL-3.0 with some enterprise-gated features.

Code-first workflows (Python/TS/Go/Bash) with auto-generated UIs and schedules — a middle path between n8n's visual style and Temporal's heavy durability, in a single Rust binary.

⚠ AGPL matters if you embed it in a distributed product. Smaller community/integration catalog than n8n. Enterprise edition gates things like full audit logs and SAML.

Built into Claude Code at no extra cost; hooks are shell commands configured in settings.json (PreToolUse, PostToolUse, UserPromptSubmit, Stop, SessionStart, etc.)

Deterministic automation the model can't skip: auto-format/lint after edits, block dangerous commands, inject context on prompt submit, fire notifications or downstream pipelines on Stop

⚠ Hooks run arbitrary shell with your user's permissions — audit anything copied from the internet. Communicate via exit codes and JSON on stdin; a hook that hangs blocks the whole session. Matcher patterns are easy to get subtly wrong; test with a no-op echo first.

Most skills Apache 2.0; the production docx/pdf/pptx/xlsx document skills are source-available (not OSS). Installable free via /plugin marketplace add anthropics/skills

Canonical reference for the SKILL.md format and the Agent Skills spec; production-grade document-creation skills to study or reuse; base library before writing your own

⚠ Document skills are source-available, not open source — check the licence before redistributing. Skills load at session start; editing a skill mid-session won't take effect until restart. The spec also lives at agentskills.io and is being adopted cross-tool, so check compatibility notes.

Free, open source; ships as an Anthropic marketplace plugin. Works across Claude Code, Cursor, Codex, Copilot CLI, Gemini CLI, OpenCode

Enforcing a full dev methodology with zero config: brainstorm -> written plan -> TDD -> systematic debugging -> code review -> clean branch finish, plus subagent-driven development and git-worktree workflows

⚠ Adds real token overhead every session — the discipline costs context. Skills sometimes fail to trigger; fixes are fresh session or explicitly naming the skill. Viral star counts (28K-174K claimed in different sources) are unreliable; judge it by the skill content, not the hype.

Free curated list of skills, hooks, slash commands, agents, status lines, orchestrators, and plugins

Discovery layer — first stop before writing a skill or hook from scratch; emphasis on code quality, security, and originality in what gets listed

⚠ As of mid-2026 the repo is mid-reorganization (old table of contents retired). Listed quality varies widely; hooks and plugins execute arbitrary code, so vet before installing. Several near-identical forks (alMubarmij, Panniantong) circulate — use the original.

Action itself is free and open source; runs on GitHub Actions free minutes (unlimited on public repos). You pay Anthropic API tokens, or use a Claude subscription OAuth token

@claude mentions on issues/PRs to answer questions or implement changes; automated PR review loops; supports Anthropic API, Bedrock, Vertex, and Foundry auth

⚠ Review output is not posted visibly to the PR by default (open issue #1008) — you must prompt it to comment explicitly. Known exit-code-5-after-success bug on some Bedrock setups (#846) can fail green pipelines. A complex PR review costs roughly $0.50-$1.50 in tokens.

Free, open source (Apache 2.0); npx @playwright/mcp@latest, no account needed

The screenshot-iterate loop: agent renders localhost, snapshots, diffs against the design goal, re-edits, repeats. Default accessibility-tree snapshot mode is deterministic and needs no vision model; --vision flag for pixel work

⚠ Accessibility snapshots of big pages bloat context fast — scope to the element under iteration. Vision mode only pays off with coordinate-capable models. Keep it pointed at localhost/staging; an agent driving a logged-in production browser is a footgun.

Free tier around 1,000 API credits/month (believed current mid-2026 — verify before depending on it); official MCP server makes it a drop-in agent tool

LLM-shaped web research: decompose question -> parallel sub-queries -> triangulate claims across 2+ sources -> cited synthesis. Cleaner extraction than raw scraping; search_depth knob trades latency vs quality

⚠ Credits burn fast with advanced-depth searches and raw-content extraction. Snippets can be stale or SEO-spam — triangulate anything load-bearing. Free-tier limits have shifted over time; check the pricing page.

Completely free, open source (MIT)

Agents doing GitHub ops without a browser: PRs, issues, releases, Actions runs, and gh api for anything the subcommands don't cover. The standard way coding agents create PRs

⚠ Interactive flags don't work in agent contexts — always pass explicit args. Token scopes bite when crossing orgs or using fine-grained PATs. gh api is rate-limited like the REST API (5,000 req/hr authenticated).

Completely free, open source (MIT/Unlicense)

The search backbone of nearly every coding agent (Claude Code's Grep tool wraps it). Orders of magnitude faster than grep -r on big repos because it parallelizes and skips ignored files

⚠ Respects .gitignore and skips hidden files by default — use -uu when hunting config or generated files. Multiline matching needs -U explicitly. Regex syntax is Rust's regex crate, not PCRE: no backreferences or lookaround without --pcre2.

Completely free, open source (MIT)

JSON glue between agent steps: filtering API responses, reshaping tool output, assembling payloads in hooks and CI. Pairs with gh api and curl as the standard agent data pipeline

⚠ The filter language has a real learning curve (it's a functional language, not a flag set). Large files need --stream to avoid loading everything in memory. Quoting hell inside YAML/CI strings — prefer jq -f filter.jq for anything non-trivial.

Completely free, open source (LGPL/GPL depending on build flags)

Letting agents do media work without a GUI: contact-sheet frame grids so an LLM can 'see' a video cheaply, transcode, trim, concat by edit-decision data, audio extraction for transcription pipelines

⚠ Filtergraph syntax is notoriously fiddly — have the agent build commands incrementally and verify each output exists and plays. GPL builds (libx264) constrain redistribution. Re-encoding loses quality; prefer -c copy stream copies for pure cuts.

Completely free, open source; run open-weight models (Llama, Mistral, Qwen, DeepSeek, etc.) locally with an OpenAI-compatible API on localhost:11434

Zero-cost bulk/background inference: classification, summarization, embedding, draft generation, and A/B baselines against hosted models — keeps sensitive data on-device

⚠ Quality and speed are bounded by your RAM/VRAM; on iGPU laptops large models run CPU-bound and slow. Quantized weights (Q4) lose measurable quality vs hosted frontier models — fine for bulk work, wrong for judgement calls. Model files are large (4-40GB+); watch disk.

Unlimited minutes on public repos; 2,000 Linux min/month on private repos (Free plan) + 500MB package storage. Jan 2026 cut per-minute overage prices 25-40%

Default CI/CD for almost everything: test/build/deploy, scheduled agent jobs (cron), claude-code-action PR automation, publishing to Pages/Vercel/Cloudflare

⚠ Minutes don't roll over; Windows burns 2x and macOS 10x the Linux allocation. A new ~$0.002/min platform fee landed March 2026 on hosted runners (sources conflict on whether self-hosted private runners are also hit — verify on your bill). Cron schedules on free tier can fire late or be skipped under load.

Personal plan: 500 free macOS M2 build minutes/month, unlimited apps, 1 parallel build. Teams are paid (per active user + per-minute)

Mobile CI when you have no Mac: iOS/Flutter/React Native builds and signing in the cloud — the main free way to produce an iOS build from a Linux laptop

⚠ 500 minutes vanish fast — iOS builds commonly run 10-20 min each, so budget roughly 25-50 builds/month. Free tier is single-user; adding any teammate moves you to paid. iOS distribution still needs the $99/yr Apple Developer account regardless.

Free forever for personal/non-commercial use: unlimited projects and deployments, 100GB fast data transfer/mo, 1M function invocations/mo, 4h active CPU/mo, preview deployments, automatic HTTPS

Next.js and frontend apps with serverless functions; instant preview URLs per push make it ideal for agent-built sites and demo links

⚠ Non-commercial only — ads, affiliate links, or e-commerce on Hobby violate ToS and risk suspension; anything earning money needs Pro ($20/user/mo). Hard caps: hit the transfer or CPU limit and you wait for the monthly reset. CLI-deploy and git-integration flows can fight each other — pick one per project.

Unlimited bandwidth and requests for static assets, 500 builds/month, unlimited sites; Pages Functions share the Workers free tier (100K requests/day, 10ms CPU/request)

Static and JAMstack sites that might get traffic spikes — unlimited free bandwidth is the differentiator vs every competitor; commercial use allowed on free tier

⚠ Cloudflare is steering new projects toward Workers with static assets; Pages still works but is no longer the flagship, so check feature parity before starting new builds there. Functions' 100K req/day and 10ms CPU limits rule out heavy SSR. Build images occasionally lag latest framework versions.

Free static hosting from any public repo (private repos need a paid plan): ~100GB bandwidth/month soft limit, 1GB site size, 10 builds/hour

Docs, project landing pages, portfolio sites, and anything already living in a GitHub repo — zero extra accounts, deploys via Actions

⚠ Static only — no server-side code at all; pair with a Worker or external API for dynamics. The 100GB/mo bandwidth is a soft limit but heavy sites get throttled. Custom domain HTTPS setup still trips people on apex vs CNAME records. Explicitly not for commercial e-commerce per ToS.

Free CPU Basic Spaces (2 vCPU, 16GB RAM) with Gradio/Docker/static SDKs; free ZeroGPU access (dynamic NVIDIA H200, ~3.5 min/day quota for logged-in users); 100K monthly inference-provider credits

ML demos with a GPU behind them for $0 — the only free tier that gives you H200 seconds; ideal for model showcases, Gradio prototypes, and shareable AI experiments

⚠ Free Spaces auto-sleep after ~48h idle and cold-start slowly. ZeroGPU daily quota is minutes, not hours — fine for demos, useless for batch jobs. Users reported (Apr 2026 forums) free CPU Spaces unexpectedly hitting quota errors despite 'unlimited hosting' wording, with inconsistent error messages — behavior is in flux, don't bet production on it.

Free hosting and download of ~2M models, datasets, and Spaces; free inference widgets; community leaderboards as Spaces

Finding open-weight models and datasets; the de facto registry for anything open. Datasets tab doubles as the main free training/eval data source

⚠ Quality varies wildly — sort by downloads/likes and check the model card licence (many 'open' models are non-commercial). Serverless inference API is heavily rate-limited on free tier

Fully free: crowdsourced pairwise-vote Elo rankings across ~9 arenas (Text, Code, Vision, WebDev, Image/Video gen, Search); also free side-by-side model chat

Quick read on which frontier model users actually prefer; vibes-check on brand-new releases (models added within 1-2 weeks)

⚠ Measures human preference, not capability — style/verbosity bias is real (use the style-control view). Top ranks are often within confidence intervals of each other; treat top-3 as a statistical tie

Free dashboards comparing models and API providers on intelligence index, price per 1M tokens, latency, and output speed

Choosing a model+provider on cost/speed/quality trade-offs before wiring an API; the standard independent aggregator cited across the industry

⚠ Their composite 'intelligence index' is their own blend of benchmarks — read the per-benchmark breakdown, not just the headline number. Provider speed figures fluctuate; re-check before committing

Free leaderboards (Verified, Full, Lite, Multimodal, bash-only) plus the benchmark dataset and harness on GitHub

Comparing coding agents/models on real GitHub-issue repair; the reference benchmark for agentic coding

⚠ Scaffold dominates: the same model scores wildly differently under different harnesses (e.g. SWE-bench Pro: 80.3% vendor scaffold vs 59.1% standardized vs 47.1% private set, June 2026). Prefer standardized runs (mini-swe-agent, Scale SEAL) over vendor-reported numbers; contamination of the Verified set is an open debate

Free leaderboard; questions, code, and per-category scores fully open

Contamination-resistant capability check — monthly-refreshed questions with objective ground-truth scoring (no LLM judge) across math, coding, reasoning, language, IF, data analysis

⚠ Smaller task set than the big aggregators and new models can lag a refresh cycle; coding category correlates only loosely with agentic benchmarks like SWE-bench

Free leaderboard; benchmark code open (Aider-AI/polyglot-benchmark)

Practical pair-programmer signal: code editing across 6 languages with diff-format compliance, plus cost per run — good complement to SWE-bench

⚠ Update cadence has slowed since 2025 (community has flagged this; some new models added late or not at all — third-party reruns exist on llm-stats.com). Treat as a secondary, slightly stale source in mid-2026

Free live rankings: weekly token volume per model, market share by lab, tool-call and multimodal usage; plus a rotating catalog of ~30 fully free models to test against

Revealed-preference intel — what builders actually run in production, not what benchmarks say; spotting fast-rising cheap models early

⚠ Only measures OpenRouter traffic, which skews toward free/cheap models, roleplay apps, and coding agents — absolute share misleads on enterprise use. Free model catalog churns constantly

Free archived leaderboard of 13k+ open models on the old eval suite

Historical reference only — comparing pre-2025 open models on a uniform harness

⚠ RETIRED March 2025; no new submissions, frozen scores. Anything citing it as current is stale. Use LMArena, LiveBench, or the ~200 community leaderboards on HF instead

Free; ~62k-star curated list of MCP servers by category with language/scope/OS tags; companion list awesome-mcp-devtools for SDKs and testing tools

Discovering an MCP server for a given integration before writing one yourself; broadest single MCP index

⚠ Huge and loosely gated — many entries are abandoned or low-quality. Vet each server before install: unmaintained or malicious MCP servers are a real prompt-injection/supply-chain vector. Glama badge scores help triage

Free; ~60k-star official repo of reference MCP server implementations plus links to community servers

Canonical, maintained implementations to copy patterns from when building your own MCP server; safer default than random community servers

⚠ Many early reference servers were archived/moved to community maintenance during 2025 — check the README status table before depending on one

Free; curated index of LLM papers, training/deployment frameworks, courses, tutorials, and public checkpoints/APIs

Building CS/ML literacy systematically — the milestone-paper list (e.g. CoT, RLHF lineage) is a good structured reading path

⚠ Paper-and-framework heavy, light on agents/MCP-era tooling; some sections update slower than the field moves. Use for foundations, not for this-month news

Free; curated list of AI agent frameworks, open-source agents, and agent products, split open-source vs closed

Mapping the agent-framework landscape before picking one; finding niche agents to study or fork

⚠ Maintained by E2B (a sandbox vendor) so mild curation bias; agent projects churn fast — verify a listed project is still alive before adopting. (Entry verified from prior knowledge; URL stable but star count not re-checked June 2026)

Free; 100k+ stars; 100+ runnable example apps — agents, multi-agent teams, RAG variants (CRAG, hybrid, vision), voice agents, MCP agents, framework crash courses

Working starter code: clone a near-match example instead of scaffolding an agent/RAG app from zero; covers OpenAI/Anthropic/Gemini and local open models

⚠ Tutorial-grade code, not production — minimal error handling, eval, or security. Examples track framework-of-the-month; pin dependencies because samples rot fast

Free; official notebooks/recipes for Claude — tool use, RAG, sub-agents, vision, prompt caching, evals, structured output

Copy-paste-grade reference patterns when building on the Claude API; the patterns (agentic loops, caching) transfer to other providers

⚠ Anthropic-centric and recipes can lag model releases — check model IDs and API params against current docs before shipping

Free; ~147k-star official Agent Skills repo — SKILL.md-format folders (docx/pptx/xlsx creation, MCP builder, claude-api, design skills) usable in Claude Code, claude.ai, and via API

Drop-in capabilities for Claude-based agents and the canonical reference for authoring your own skills; the skill format is plain markdown+scripts, so it ports to other agent stacks

⚠ Skills execute code in the agent environment — review bundled scripts before enabling, same supply-chain caution as MCP servers. Format is Anthropic-defined and still evolving

Free daily digest auto-summarizing X, Reddit, and top AI Discords, with human-curated headline section; Latent Space newsletter/podcast also free

Single highest-density daily intel feed for AI engineers — catches model releases, repo launches, and discourse the same day

⚠ AINews merged into Latent Space in Jan 2026 — follow @latentspacepod / latent.space for continuity. It is a firehose; read the curated top section and skip the rest or it eats an hour

Free weekly newsletter (~116k subs) from Anthropic co-founder Jack Clark: research analysis, compute/policy trends, safety

The research-and-governance layer the dev newsletters skip — useful for the 'favourable outcomes for humans' lens: concentration of power, compute trends, policy direction

⚠ Weekly and analytical, not a tool tracker — won't tell you what to install. Author is an Anthropic insider; calibrate for house perspective

Free CC-BY-4.0 databases: 2,800+ notable AI models (params, training compute, cost), frontier data centers, GPU clusters, chip sales, AI companies, benchmark results — all downloadable as CSV/zip

Hard numbers for trend analysis, content, or builds (e.g. Resource Atlas-style projects): training-compute doubling rates, energy/data-center footprints, cost curves

⚠ Curated research data, not live telemetry — frontier entries rely on estimates with stated uncertainty; weeks-to-months of lag on newest models. Cite with the CC-BY attribution

Fully free, GPL, commercial use unrestricted. Rigify auto-rigging, Geometry Nodes procedural animation, Grease Pencil 2D/3D hybrid animation, NLA editor, native glTF + USD I/O.

The backbone of any zero-budget 2D+3D pipeline; one tool covers rigging, animation, roto-masking, compositing, and export to engines. Paid-work credibility: studios accept Blender deliverables via FBX/glTF/USD.

⚠ Rigify rigs need cleanup before game-engine export (bone roll, deform-only filtering). Grease Pencil renders on CPU/EEVEE fine on the Latitude iGPU, but heavy Geometry Nodes sims will crawl. Runs well where native-GL NLEs (DaVinci/Kdenlive) blank out.

Entirely free (Adobe account only): web auto-rigger for humanoid meshes + ~2,500 mocap animations, royalty-free for commercial use.

Fastest path from a static character mesh to a walking/fighting/dancing character; standard skeleton retargets cleanly to Godot/Unity/Unreal/Blender.

⚠ Effectively in maintenance mode — Adobe hasn't updated it in years and could sunset it; download a local library of the animations you rely on. Humanoid bipeds only, no facial or finger nuance, no API for batch work (web UI only).

Free tier includes the physics tools, AutoPosing, and most new features — but exports to the proprietary .CASC format ONLY (verified June 2026 pricing page).

Learning physics-believable character animation fast; AutoPhysics fixes weight/balance that hand-keying gets wrong.

⚠ The export wall is the whole catch: FBX/DAE/USD/glTF export needs Indie ($96/yr, <$100k revenue) — so free tier can't feed a paid pipeline. Sweetener: yearly Indie/Pro converts to a perpetual license after 1 year, so one paid year is a one-off cost, not lock-in.

Unlimited free captures up to 15 seconds, single camera (webcam or uploaded video), browser-based. Clean-up + retarget in free Rokoko Studio; exports FBX/BVH.

Quick mocap of your own acting/movement performance — directly monetisable given the performance background: capture your own combat/creature movement and sell or reuse the clips.

⚠ 15s/clip cap on free (chain clips for longer takes); dual-cam accuracy is ~€240/yr. Hosted service — performance data goes through their cloud. Tracking drifts on fast occluded moves.

Fully open source (AGPL), $0: multi-webcam markerless full-body capture built on MediaPipe-class pose estimators, with a Blender add-on for skeletal import.

Unlimited-length, no-cloud mocap sessions; owning the whole pipeline. MediaPipe itself (Apache 2.0) is the underlying pose tech if you want to script custom capture.

⚠ Setup is fiddly (camera calibration, lighting, Python env) and output needs manual cleanup vs Rokoko's filtered result. CPU-heavy processing is slow but feasible on the Latitude. Quality varies run to run — budget cleanup time per take.

MIT licensed, $0 forever: AnimationTree state machines + blend spaces, runtime bone retargeting (SkeletonProfile), IK modifiers, AnimationPlayer for cutscenes, glTF-native import.

Shipping interactive/game animation without engine royalties — pairs with the existing Godot+Monado+Quest 3 stack (Frankensteingine). Retargeting profile maps Mixamo/Rokoko skeletons onto custom characters in-engine.

⚠ Retargeting UI is functional but less polished than Unity Humanoid; root motion needs explicit setup. 4.x animation API has had breaking changes between minors — pin the editor version per project.

All open source: Khronos glTF validator/sample tools, Blender's native glTF I/O, Pixar OpenUSD libraries + usdview, Apache 2.0.

Client-proof deliverables: glTF for web/engine handoff (the 'JPEG of 3D'), USD for studio-grade scene interchange. Knowing USD composition (layers/references) is a billable studio skill in itself.

⚠ USD's C++/Python build is heavy; prefer prebuilt wheels (usd-core on pip). glTF animation supports skeletal+morph only — no constraint/rig logic survives export, so bake everything first.

Fully free, open source (modified BSD) — the production lineage is real: derived from Toonz as used by Studio Ghibli.

Full traditional 2D production: scanning paper drawings, vector/raster levels, xsheet workflow, effects compositing. Most complete free answer to Toon Boom Harmony.

⚠ UI is dated and crash-prone vs commercial tools — save incrementally. Steeper learning curve than Krita for simple shot work; worth it only for xsheet-style multi-scene production.

Fully free, GPL. Brush engine ranks with Photoshop, onion skinning, animation timeline, audio scrub, export via FFmpeg.

Hand-drawn frame-by-frame shots, animatics, and polished 2D frames for AI-assisted pipelines (keyframes to feed ToonCrafter/RIFE).

⚠ Timeline is per-layer raster only — no bones/tweening (use Blender Grease Pencil or OpenToonz for that). Long scenes eat RAM; keep shots short.

RIFE model + code free (MIT); Flowframes GUI free (donation-optional on itch). Also exposed inside Blender add-ons and ComfyUI nodes.

Animating on 2s/4s (every 2nd/4th frame) and letting RIFE fill intermediate frames — the single biggest time-multiplier for solo 2D animation. Also smooths choppy mocap renders.

⚠ Optical-flow interpolation smears on large pose changes and breaks on held cels with moving camera — for big keyframe gaps use generative inbetweening instead: ToonCrafter (github.com/Doubiiu/ToonCrafter, Apache 2.0 weights, but ~24-26GB VRAM — free HF Space or rented GPU only, won't run on the Latitude iGPU). GPU strongly preferred for RIFE too; CPU mode works for short clips.

Open weights, free; mature ComfyUI node ecosystem (AnimateDiff-Evolved) with motion LoRAs, prompt travel, vid2vid stylisation.

Stylised loops, vid2vid restyling of mocap/3D renders (relevant to the Singularity-shots clay-pass-then-restyle pipeline), and music-video-style work that sells on social.

⚠ SD1.5-era base — temporal consistency well below Wan/LTX in 2026; treat as a stylisation tool, not a video generator. Needs ~8-12GB NVIDIA VRAM: cloud GPU required from the Latitude.

Open weights, Apache 2.0, commercial use allowed. 14B (MoE, 27B total) and smaller 5B variants; mature, well-documented ComfyUI workflows.

Best open-weights motion quality in mid-2026 — cinematic camera moves and physical motion for animation previz, shorts, and client video at $0 model cost.

⚠ 720p native, no audio. Note Wan 2.5/2.6 moved behind Alibaba's paid API — 2.2 is the last fully open one, so pin your weights. Hosted-China-model rule doesn't bite (local open weights), but it needs a 16-24GB NVIDIA GPU — rent or use free-tier hosted inference. CLAUDE.md open-weights-Chinese question still officially open.

Open weights; LTX Model License = free including commercial use for under $10M revenue (Apache-2.0-like below that bar). Official ComfyUI nodes; very fast generation, native synced audio, native 9:16, up to 4K.

Rapid iteration and short-form social output (9:16 + audio in one pass) — the cheap-tries arm vs Wan's fewer-better-takes arm.

⚠ Revenue-capped license, not pure Apache — fine for indie scale, recheck terms before building a product on it. Frame counts must be N×8+1 or generations misbehave. Newer LTX-2.3 nodes still maturing vs Wan's ecosystem.

ComfyUI GPL and free; OpenPose/Depth/Lineart ControlNet weights free on Hugging Face for SD/SDXL/Flux-class models.

The glue layer: pose-controlled character frames (render Godot/Blender pose passes, drive ControlNet), depth-consistent backgrounds, and chaining Wan/LTX/AnimateDiff/RIFE into one reproducible graph. Workflows are JSON — versionable, resellable.

⚠ Custom-node ecosystem is the win and the supply-chain risk — nodes run arbitrary Python; vet or containerise per the R&D containment posture (Docker first). Local GPU still required for serious throughput.

Remotion free for individuals and companies up to 3 people (company license above that); Theatre.js fully open source (Apache 2.0) — sequencing UI for any JS animation, pairs with React Three Fiber.

Already proven in this house (wand-combat reel, singularity-shots): data-driven cuts, captions, kinetic type, and 3D-in-browser animation rendered headlessly — the iGPU-safe NLE substitute, and a directly billable web-dev+animation crossover skill.

⚠ Remotion's license flips to paid if a client company >3 employees renders with it — check whose infra renders the final. Theatre.js development has slowed since 2024; stable but verify maintenance before deep dependence.

Meta's open release, Apache 2.0 code + permissive weights: click-to-segment objects and propagate masks across video.

Free rotoscoping that replaces DaVinci Studio's paid Magic Mask: cut performers out of footage for reels, comping, and vid2vid mattes. Pairs with Blender compositor or ffmpeg for the actual comp.

⚠ DaVinci Resolve free exists but is moot here — native-GL NLEs blank on the Latitude iGPU (known trap). SAM2 inference wants a GPU for video; HF Spaces/Colab free tiers handle short shots. Masks need edge cleanup (no motion-blur-aware matting).

Free forever: contact/deal management (up to ~1M stored contacts), email tracking, meeting scheduler, forms, live chat, 2,000 marketing email sends/month.

The default free pipeline for Booked Out / DTR-style founder-led sales: deals board + email logging with zero setup cost, and clients recognise the name.

⚠ Verified June 2026: marketing usage is the real cap — ~1,000 marketing contacts and 2,000 sends/mo, HubSpot branding on emails/forms, no sequences or automation on free. The free tier is a funnel into $20+/mo Starter; export your data model cleanly so you can leave.

GPL-licensed, self-host free with unlimited users/records; modern Notion-like UI, GraphQL/REST API, active development (20k+ GitHub stars).

Owning your pipeline data outright — fits the Hetzner-box habit; API-first so agents (Hermes/Claude) can read/write deals programmatically, which hosted free tiers mostly block.

⚠ Self-hosting = you are the ops team (Postgres + Redis + updates); the Hetzner ARM box is already RAM-tight at 3.7GB. No email sending built in — pair with Brevo/Mautic. Hosted cloud version is paid.

NO permanent free tier as of 2026 — 14-day trial only, then $20-24/user/mo (account is blocked if you don't upgrade).

Honourable mention only: folkX Chrome extension capturing LinkedIn profiles into a CRM is genuinely slick if you later pay.

⚠ Listed because it's commonly mis-cited as having a free plan — it doesn't (verified June 2026, folk.app/pricing). Data is hostage after trial ends until you pay. Use HubSpot free or Twenty instead at $0.

Free plan: access to the ~270M contact database, unlimited email viewing credits (fair-use), ~250 emails/day sending, 2 active sequences, 5 mobile + 10 export credits/month, Chrome extension, CRM integrations.

Best free B2B prospect database by a wide margin — find the right person at NZ/UK trade-adjacent firms, agencies, or studios and get a verified email without paying.

⚠ Free limits are shifting without notice (2026 user reports of credit cuts from 10k to ~720/mo); don't build a workflow that assumes today's caps. 10 exports/mo means work inside Apollo's UI, not CSV. GDPR: you're the data controller when emailing UK/EU prospects — keep lawful-basis notes.

25 email searches + 50 verifications/month, domain search, Chrome extension, plus cold-email campaigns to 500 recipients/mo with 1 connected sending account.

Lightweight complement to Apollo: paste a company domain, get the email pattern. The free campaign tool is a genuinely usable mini-sequencer for low-volume founder outreach.

⚠ Email-only on every plan (no phone numbers). 25 searches/mo is hobby-scale — treat as a verifier/second source, not the primary list builder. Verified June 2026.

Free plan with ~100 credits/month plus 14-day Pro trial; waterfall enrichment across dozens of data providers, AI research agent (Claygent), table-based workflows.

Learning the highest-leverage modern GTM skill (enrichment waterfalls + AI research columns) — Clay operators bill £75-150/hr as freelancers, so the tool is itself a sellable skill.

⚠ Credit figure not re-verified for June 2026 — Clay reprices often; confirm before relying on it. Credits burn fast (one enriched row can cost several credits). Real usage gets expensive quickly ($134+/mo) — keep free tier for learning + tiny batches.

300 emails/day free forever, unlimited contacts, drag-drop campaigns, basic automation workflows, transactional API.

The free lemlist/Mailchimp replacement: warm-up-paced founder outreach, waitlist mails (DTR win-back), and client newsletters without a per-contact tax.

⚠ Brevo branding on free emails; daily (not monthly) cap shapes send pacing. Dedicated cold-outreach tools' free warmup tiers are mostly dead in 2026 — Google/Microsoft crackdowns made inbox-warmup services ToS-risky; better play is low volume from a properly authenticated (SPF/DKIM/DMARC) custom domain.

Fully open source (GPL), self-host free: multi-step email sequences, lead scoring, landing pages, segment-triggered campaigns — the OSS HubSpot Marketing Hub.

Unlimited-contact drip/nurture automation at server cost only, owned end-to-end; pairs with Amazon SES (~$0.10/1k emails) for near-free sending at scale.

⚠ Heaviest ops burden on this list (PHP+MySQL+cron care, deliverability is entirely on you). Overkill until a list is in the thousands — start on Brevo, graduate to Mautic when the per-contact pricing bites. Containerise per containment posture.

AGPL open source, self-host free (Docker one-liner); hosted version has a limited free tier. Journals, reminders, gift/conversation logs per person.

Programmatic upgrade path for the existing ~/people/black-book.md: structured contacts + 'ping this person' reminders so industry relationships (casting, 11Labs, studio contacts) don't decay.

⚠ Manual-entry by design — no auto-enrichment or email sync; it only works if updating it becomes a habit. Development pace has slowed; fine as a stable tool, don't expect rapid features. The black-book markdown file may honestly be enough.

Free plan with a capped contact count; auto-builds your network graph from email, calendar, LinkedIn/Twitter, with relationship-strength and reconnect prompts.

Zero-effort upkeep of professional relationships — surfaces 'you haven't spoken to X in 6 months' across the acting + tech networks without manual logging.

⚠ Rebranding to 'Mesh' circa 2026 and acquired by Automattic — product direction in flux, recheck before investing. It reads your email/calendar: real privacy surface; keep NDA-adjacent contacts (Into the Dead 3, patent) out or self-host Monica instead. Don't confuse with clay.com.

Free entirely: profile README, pinned repos, GitHub Pages, contribution graph; plus targeted PRs to tools your prospects already use (Godot, ComfyUI nodes, Remotion templates, three.js).

Highest-credibility inbound for AI/3D-pipeline contract work: a merged PR in a tool a studio uses is a warmer intro than any cold email, and recruiters/founders do read profiles. Pin DTR/resource-atlas/nanny-feynman; write READMEs that state the business problem solved, not just the stack.

⚠ Slow-burn channel (months, not weeks) and easy to gold-plate — timebox it; contribution-for-visibility only counts when aimed at ecosystems where buyers live. Keep private-repo work summarised in the profile README since the graph won't show it.

Free to enter; online hackathons pay cash prizes ($1k-50k pools) and sponsor judges are often hiring managers/devrel at AI companies.

Fastest visible-win + income lane on this list given hackathon-hunter already scrapes it: a weekend AI-animation entry can return prize money, portfolio piece, and judge relationships simultaneously.

⚠ EV per hackathon is lottery-shaped — pick events where the 3D/AI-pipeline edge is rare among entrants (animation/creative-tool hackathons over generic LLM ones). Keep the human-gated never-auto-submit rule from hackathon-hunter.

Free forever: 3 connected channels, 10 scheduled posts per channel (slots refill as posts publish), browser extension, basic ideas board.

Just enough to run the stated LinkedIn+IG posting intent on autopilot: batch a week of 'different cuts of shipped artifacts' in one sitting, schedule, leave.

⚠ Verified June 2026: 10-queued-posts-per-channel cap means weekly batching, not monthly. Analytics and engagement tools are paid. Upgrading charges per channel including the formerly free ones. Watch the brand-as-procrastination trap — schedule from shipped work only.

Free for freelancers, 0% commission — you keep 100%; clients pay a ~3% platform fee. Portfolio pages double as a personal site.

Processing payments for clients you sourced yourself (outreach, referrals, network) at 0% instead of Upwork's 10% — and as a discoverable portfolio for web-dev/3D/AI-tooling services.

⚠ Much lower job volume than Upwork (~60% less by 2026 comparisons) — treat as the payment/portfolio rail plus supplementary marketplace, not the primary demand source. Dispute protection is thinner than escrow-heavy platforms; contract terms matter more.

Free for creators: storefront with rates/audience stats, scheduling, payments. Brand pays the 2% transaction fee; a 15% fee applies only on deals Passionfroot's network matches for you.

Monetising the personal-brand posting lane once LinkedIn/IG/YouTube traction exists — B2B AI-tool sponsors actively buy placements from small technical creators, which maps onto AI-pipeline content.

⚠ Needs an audience first (sponsors filter on reach) — sequencing: ship content for 3-6 months, then open the storefront. B2B niches (AI/dev tools) monetise at much smaller follower counts than consumer niches.

Free tier: browse and audition for open VO/performance roles (games, animation, audio drama); many roles are paid indie gigs. Premium (~$8/mo) adds early access and more auditions.

Converting the voice-acting skill to cash and credits between agency bookings — indie game/animation VO clients here also commission animation/pipeline work, so one booking can open two lanes.

⚠ Rates skew low (indie budgets, some revshare/unpaid — filter hard for paid-only). Free tier caps monthly auditions and surfaces listings later than premium. Competition is high; a tight 60-second demo reel matters more than volume.