DEV Community: Reno Lu

HTML Anything makes the coding CLI you already run write your HTML

Reno Lu — Sun, 02 Aug 2026 14:23:47 +0000

The tool ships no model

HTML Anything makes a bet most AI design tools avoid: it ships no model and asks for no API key. On startup it scans your PATH for a coding-agent CLI you have already logged in, then hands that agent the job of writing HTML. Claude Code, Cursor Agent, Codex, Gemini CLI, GitHub Copilot CLI, OpenCode, Qwen Coder, and Aider are all detected automatically, including from the odd install directories a GUI-launched Node process usually misses, like ~/.local/bin and /opt/homebrew/bin. You swap between them from a top-bar picker. Because the work runs through the session you already pay for with claude login or cursor login, the project puts the marginal cost at zero dollars.

That framing inverts the usual pitch. Instead of renting you inference, nexu-io/html-anything reuses inference you already have, and keeps the whole loop local.

HTML as the finished form, not Markdown

The reason to bother is an argument the README borrows from Anthropic's Claude Code team, who said they stopped writing internal docs in Markdown and now ship HTML. HTML Anything runs with that idea. Markdown is good for the writer; HTML is good for the reader. Markdown's layout is whatever the renderer decides, while HTML's layout is yours. A Markdown file screenshotted into a tweet looks like a text file, while an HTML page already looks like a designed image. The project's word for the goal is "ship-ready": when generation finishes, the artifact is what your audience sees, with no touch-up pass promised for later.

You feed it Markdown, CSV, Excel, JSON, SQL, or raw notes, press ⌘+Enter, and the local agent returns a single-file HTML page. From there, one click sends it to WeChat, X, or Zhihu, or downloads .html or .png.

75 skills across 9 surfaces

What keeps the output from looking generic is a library of 75 composable skill templates, each defined by a SKILL.md file, spread across nine deliverable surfaces: magazine articles, keynote decks, résumés, posters, Xiaohongshu cards, tweet cards, web prototypes, data reports, and Hyperframes videos. The featured skills are specific rather than vague. deck-swiss-international builds a 16-column grid with one saturated accent across 22 locked layouts. deck-guizang-editorial offers 10 locked layouts across five palettes and reads like a printed art-zine. doc-kami-parchment swaps plain white for a #f5f4ed ground and a single serif voice for long reading. video-hyperframes emits 6 to 10 sequential 1920×1080 frames with hidden duration and transition markers, ready to hand to Remotion for an .mp4.

The constraints inside each SKILL.md are where the project spends its discipline: a CJK-first font stack, an 8 px baseline grid, a minimum contrast ratio, and a rule that says use real data, not placeholders. That last set comes from alchaincyf/huashu-md-html, one of four open-source projects the README credits by name. The others are nexu-io/open-design for the agent-detection layer and the SKILL.md protocol, mdnice/markdown-nice for CSS that pastes cleanly into WeChat and Zhihu, and gcui-art/markdown-to-image for the iframe-to-PNG export path.

Who it fits

HTML Anything is narrow on purpose. It suits people who publish to Chinese platforms like WeChat and Xiaohongshu as much as to X, who already work inside a coding-agent CLI, and who would rather generate a finished page than open a design tool. If you do not already have one of those CLIs logged in, the whole zero-key premise falls apart, and the README is upfront that the sandboxed preview and the export chain are the parts doing the polishing. For the audience it targets, the pitch holds together: the format readers want is HTML, and the agent you already pay for can write it.

GitHub: https://github.com/nexu-io/html-anything

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

How academic-research-skills-codex ports a Claude Code suite to Codex

Reno Lu — Sat, 01 Aug 2026 14:22:37 +0000

Imbad0202/academic-research-skills-codex is not a new research tool. It is a careful port of an existing one. The repo takes the Academic Research Skills suite, originally written for Claude Code, and repackages it so OpenAI Codex can run the same workflows. Most of the engineering here is not about academic writing at all. It is about making one AI agent's skill format work faithfully inside a different agent's runtime.

That framing matters because the two editions are kept in deliberate lock-step. The Codex package carries its own version number, 0.1.18, tracked across the root VERSION file, the SKILL.md metadata, and the manifest.json adapter version. Separately, it records exactly which commit of the upstream Claude Code repo it vendors: academic-research-skills at commit 73c898c, tagged v3.16.0. The README treats the upstream checkout as read-only. Content gets copied from fresh clones and adapted through a router, never edited in place. So you can trace a given behavior back to a specific upstream commit.

What the suite actually does

Once installed, you invoke everything through a single skill, $academic-research-suite. You describe the task in plain language, and a Codex adapter routes the request to one of five workflows. deep-research handles question refinement, literature review, systematic review, meta-analysis, and fact-checking. academic-paper covers outlining, drafting, abstracts, revision, citation formatting, and AI disclosure. academic-paper-reviewer runs simulated peer review and produces journal-style decision letters. academic-pipeline chains the whole thing from topic to revised manuscript with integrity gates in between. experiment-agent plans code experiments and human studies and checks reproducibility.

The suite is built to slow you down rather than hand you a finished paper. If you arrive with a topic but no clear research question, the router is supposed to start in Socratic mode and ask narrowing questions, and it should refuse to produce an outline until the question has converged. The vendored v3.16 content adds risk-stratified cross-model verification, blind disagreement checkpoints, and a Material Passport that tracks which citations a human has actually read. Aliases like ars-mark-read and ars-cache-invalidate exist specifically to record human-read signals and to invalidate cached verification for a single citation key. This is a research assistant designed around the assumption that the human stays responsible for the claims.

The adaptation is the interesting part

Codex does not share Claude Code's plugin command registry, so the package cannot ship real slash commands. Instead it emulates the command intent inside the one skill. The README documents three ways to trigger an alias depending on how your Codex client handles slash-prefixed text, which is an honest admission that the shim is imperfect and client-dependent.

The portability details are the most telling. When you install through Codex Desktop as a plugin, the plugin's skills directory holds a materialized copy of the suite rather than a symlink. The stated reason is Windows: plugin caches there can turn symlinks into plain text files and then skip registering the bundled skill. Vendored upstream .github workflows and agent mirrors are kept only for traceability and self-tests, not wired up as CI. Claude-specific loader files under .claude and .claude-plugin are intentionally excluded. Each of these is a small decision about what survives the jump from one runtime to another.

The README is also candid about rough edges. Some Codex warnings, like a deprecated hooks feature or hooks that need review, are called out as non-blocking noise rather than failures. There is a maintainer quality-gate script and a CLI smoke test so you can confirm the router classifies a request correctly before trusting it.

For anyone maintaining a skill across both Claude Code and Codex, academic-research-skills-codex is a working reference for how that split gets managed: version the adapter on its own track, pin the upstream by commit, materialize copies where symlinks break, and document the shim's limits instead of hiding them. The academic workflows are the cargo. The packaging is the lesson.

GitHub: https://github.com/Imbad0202/academic-research-skills-codex

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

text-to-cad ships CAD agent skills that run from a prompt to a Bambu Lab print

Reno Lu — Fri, 31 Jul 2026 15:13:01 +0000

text-to-cad does not ship a text-to-CAD model. It ships eleven agent skills, each a SKILL.md workflow, that turn a general coding agent into one that writes real mechanical geometry and carries it all the way to a physical printer. Published as "CAD Skills," the repo installs with npx skills install earthtojake/text-to-cad or as a native plugin for Codex and Claude Code.

The core CAD skill takes a plain-language or image request and produces a STEP file, with STL, 3MF, and GLB as alternate exports. That is the entry point. The more interesting part is what sits downstream of it.

A chain from prose to a physical part

Read the skill table as a pipeline and the design becomes clear. The CAD skill makes the solid. The DXF skill flattens it into 2D drawings: profiles, gaskets, cut layouts. The SendCutSend skill checks those DXF and STEP files before you upload them to the fabrication service. For 3D printing, the G-code skill slices supported meshes into printer-profiled .gcode using real slicer CLIs, not a reimplementation of one. The Bambu Labs skill then dry-runs, uploads, and cautiously starts a print job on a local Bambu Lab printer from that validated gcode.

So the arc runs from a sentence to a running print, with a validation step before anything gets cut or extruded. Two supporting skills round it out: step.parts finds off-the-shelf STEP parts like screws, bearings, motors, and connectors, and CAD Viewer opens local browser previews for CAD, G-code, and robot files so a person can look before committing.

A second chain for robots

The repo carries a parallel track for robot-description files. The URDF skill writes robot structure: links, joints, limits, inertials, meshes. The SRDF skill layers MoveIt planning groups, end effectors, poses, and collision rules onto that URDF. The SDF skill builds simulator models and worlds with frames, physics, sensors, and lights. These are the standard formats mechanical and robotics work actually runs on, and the demo gifs in the README show a URDF example and an SRDF/MoveIt2 inverse-kinematics example rendered in the same CAD Viewer.

An eleventh skill, Implicit CAD, is marked experimental. It builds browser-native models from GLSL signed-distance fields and renders them with raymarching in CAD Viewer. It sits apart from the STEP-centered main path.

Benchmarks you can read

Most "text to CAD" projects show one hero render and stop. text-to-cad ships ten benchmark tasks, each with the exact prompt and an orbiting output gif. They climb in difficulty: a rectangular calibration block with four through-holes and a chamfer, a circular flange with a six-hole bolt circle, an L-bracket with gussets and two hole directions, a stepped shaft with a keyway, an open-top enclosure with internal standoffs, an aerospace-style clevis bracket with lightening cutouts, a radial-engine cylinder with twelve cooling fins and a 35-degree angled spark-plug boss, a centrifugal impeller with backward-curved blades, a spiral staircase with a helical handrail, and a simplified planetary gear stage with separate sun, planet, ring, carrier, and pin bodies.

Each prompt names dimensions and features, so the benchmark doubles as a spec you can grade the output against. The heavy gif and benchmark assets live in Git LFS and are excluded from default pulls, so a plain clone stays light; git lfs pull --include="benchmarks/**" hydrates them when you want to look.

What it is, and isn't

The README is explicit about scope. This is a skills library, Python 3.11+, MIT licensed, that generates, inspects, sources, slices, and hands off CAD and robot artifacts from local project files. It does not claim a novel model or accuracy numbers. The benchmarks are qualitative gifs, not scored results.

What it offers instead is coverage: the boring, load-bearing formats of mechanical and robotics work, STEP, DXF, gcode, URDF, SRDF, and SDF, wired into a single agent, with a validation gate standing between the geometry and any real hardware run. For anyone who has watched an AI produce a pretty mesh that no slicer or fab shop would accept, that emphasis on real CLIs, real file checks, and a cautious print start is the whole point. text-to-cad treats the output file, not the render, as the deliverable.

GitHub: https://github.com/earthtojake/text-to-cad

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

awesome-gpt-image-2: a prompt library where each entry is structured JSON with its source attached

Reno Lu — Thu, 30 Jul 2026 15:03:01 +0000

Prompts written as structured specs

The top featured prompt in YouMind-OpenLab's awesome-gpt-image-2 is not a sentence you type. It is a nested JSON object. The "VR Headset Exploded View Poster" entry opens with keys for type, subject, style, and background, then a layout block that spells out a vertically stacked exploded view with nine internal components, eight callout labels split left and right, and a footer with a headline and body text. Half the strings are Japanese. This is the shape that repeats across the collection: a prompt is a blueprint, not a phrase.

That choice tells you what GPT Image 2 is being pushed to do. The repo's own summary of the model, drawn from community testing, leans on pixel-perfect text rendering in Chinese, English, and Japanese, cross-image consistency so a repeated character or IP stays identical across a series, and multilingual poster typography produced in a single pass. A prose prompt struggles to pin down eight labeled callouts with exact copy. A JSON layout does not.

A library organized like a design brief, with receipts

awesome-gpt-image-2 is a curated list, not a runnable tool. The Statistics table reports 12,699 prompts and a "Last Updated" timestamp down to the second, and the project describes the set as growing daily through an automated README workflow. The same collection ships in 16 languages, from Simplified and Traditional Chinese to Hindi, Thai, Vietnamese, and Turkish.

The organization mirrors how a designer actually searches. The gallery splits browsing into three axes. Use Cases covers jobs like profile avatar, YouTube thumbnail, e-commerce main image, and game asset. Style covers looks like photography, anime, isometric, pixel art, and ink/Chinese. Subjects covers things like portrait, product, food, architecture, and typography. You can arrive with a task, an aesthetic, or a thing to depict, and reach the same corpus from any of those doors.

What separates the entries from a typical prompt dump is provenance. Each one carries a Details block: an Author credited by name with a link to their profile, a Source link to the original post, a Published date, and the languages it covers. The featured VR poster credits a specific X user and links the exact tweet. The repo frames this as community collection for educational use and posts a standing takedown offer for anyone who objects to seeing their work included. That is closer to a sourced dataset than a casual gist.

Small touches for people who iterate

Some prompts carry a Raycast Friendly badge. Those use Raycast Snippets syntax to expose dynamic arguments, so a quote-card prompt ships with a quote field defaulting to "Stay hungry, stay foolish" and an author field you can swap on the fly. The VR headset prompt uses the same trick for its product name, background color, and headline. It is a quiet admission that nobody runs a prompt once. They run it ten times with small changes.

The README is honest about being the lesser view. A comparison table concedes that the GitHub page is a linear list searchable only with Ctrl+F, while the youmind.com gallery adds a masonry grid, full-text search with filters, category browsing, and one-click generation. The repo also points to a companion project, awesome-seedance-2-prompts, for turning these stills into video.

So who is this for? Anyone shipping visual work who would rather start from a working blueprint than a blank box. A marketer building a product series. Someone laying out a poster with real typography in a language they do not speak. An illustrator hunting a specific style across thousands of examples. The bet behind awesome-gpt-image-2 is that the hard part of image generation has moved from wording to structure, and that a shared, attributed, daily-refreshed library of structured prompts is worth maintaining. Licensed CC BY 4.0, it is free to build on, and the front page invites pull requests to add more.

GitHub: https://github.com/YouMind-OpenLab/awesome-gpt-image-2

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

garden-skills packages taste and process for AI coding agents

Reno Lu — Wed, 29 Jul 2026 15:04:56 +0000

ConardLi's garden-skills makes a specific bet: what holds AI coding agents back is not raw capability but taste and process discipline. Each skill in the collection ships as a full production surface with opinionated defaults and hard stop points, not a loose prompt you paste and hope works.

garden-skills is a curated set of production-ready Agent Skills for Claude Code, Cursor, Codex, and other AI coding agents. It is MIT-licensed, follows the SKILL.md spec, and offers five ways to install (a skills CLI via npx, the Claude Code plugin marketplace, pinned .zip releases, manual copy, or a git submodule). The badge counts five skills. The two the README documents in depth show what the author is actually after, and it is not just "more features."

A design skill that pushes back

web-design-engineer exists to move AI-generated web artifacts from merely functional to deliberate. Instead of treating the agent as an autocomplete for markup, it casts the agent as a design engineer: understand the product context first, declare a design system, show an early v0, build the full experience, then verify it.

The interesting part is how much judgment the skill hard-codes. It converts a brief into a five-dial Design Read covering variance, motion, density, asset dependence, and brand fidelity. It distinguishes three redesign modes, extension, preserve, and overhaul, before it touches an existing product. It carries an anti-cliche blocklist to steer away from the generic UI patterns agents default to. And it ships a Design Direction Advisor with six differentiated schools plus 25 anchored style recipes, named after real references like Linear, Aesop, Bloomberg, Stripe Press, and Mid-Century. Each recipe comes with a concrete palette, typography, signature moves, and anti-patterns, ready to paste into the design-system declaration. Underneath sit practical rules for inline React plus Babel, CSS tokens, oklch() color, container queries, and reduced-motion handling, with browser acceptance testing that runs only when you explicitly ask for it.

Video treated as a checkpointed pipeline

web-video-presentation turns scripts, articles, lessons, and talks into click-driven 16:9 web presentations that can be screen-recorded as videos. It scaffolds a Vite plus React plus TypeScript project that behaves like a video production surface: a fixed 1920x1080 stage that scales to the viewport for stable recording, a click or keyboard driven (chapter, step) cursor with one narration beat per visual step, and hidden hover-only progress controls so the stage stays clean on camera.

Again the discipline is the point. The workflow turns raw articles into narration scripts, maps script beats to full-screen scenes, and pauses at hard collaboration checkpoints for the script, the theme, the outline, the implementation mode, and optional audio. Nothing runs ahead of your approval. It includes 23 built-in themes, each with its own design signature spanning editorial, terminal, engineering, and Swiss International looks. Audio is pluggable: a provider-agnostic runner ships two built-in providers (MiniMax mmx-cli and OpenAI TTS via curl) and gives you a contract plus ready-to-paste snippets for ElevenLabs, edge-tts, Azure, Google Cloud, and the macOS say command.

The through-line across the collection

The gallery lists two more skills by name: gpt-image-2 for image generation and prompting, and beautiful-article for turning any source into a formatted article. The repo description and topics also point to a knowledge-retrieval, RAG-oriented skill, which rounds the count to five. The README does not document those three in the same depth, so their internals are worth checking in each skill's own SKILL.md before you rely on them.

What ties the documented skills together is a consistent instinct: encode the checkpoints, the named recipes, and the anti-patterns that separate competent output from output a person actually chose. A five-dial Design Read and an anti-cliche blocklist are opinions about what good looks like. Pausing a video build at five named checkpoints is an opinion about how humans and agents should divide the work.

That framing is the reason to watch garden-skills rather than any single skill in it. Most agent skill libraries expand what a model can do. This one is mostly about constraining how it does the work, so the result reads as chosen rather than generated. If that bet holds, the value of a skill collection shifts from capability coverage toward the quality of the defaults it hard-codes.

GitHub: https://github.com/ConardLi/garden-skills

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

SkillOpt trains a markdown skill file like a neural network, with a validation gate

Reno Lu — Tue, 28 Jul 2026 15:12:42 +0000

SkillOpt, from Microsoft, trains a single markdown file the way you would train a neural network, with epochs, a batch size, a learning rate, and a validation gate. The weights never move. What changes is the text of a skill document that a frozen model reads before it acts.

That framing is the whole point of the repo. Most agent skills today get hand-written, generated in one shot by a strong model, or nudged along by loose self-revision. None of those behaves like an optimizer, and none reliably beats its own starting point once feedback arrives. SkillOpt treats the skill document as the trainable state of a frozen agent and puts it through a disciplined loop: rollout, reflect, aggregate, select, update, evaluate.

How the training loop works

A separate optimizer model reads scored rollouts and proposes bounded edits to one skill document: add, delete, or replace. A candidate edit only survives if it strictly improves a held-out validation score. That gate is the core rule. Anything that fails to move the validation number gets rejected and parked in a rejected-edit buffer, which keeps training from wandering. A textual learning-rate budget caps how much the document can change at once, and an epoch-wise slow or meta update keeps the whole process stable across passes.

The output is deliberately small. The deployed artifact is a best_skill.md file, usually 300 to 2,000 tokens, that runs against the unchanged target model. Because the skill is just text the model reads, deployment adds zero inference-time model calls. You pay the optimizer cost once during training, then ship a plain document.

What the numbers say, and what they do not

The README reports evaluation across six benchmarks, seven target models, and three execution harnesses: direct chat, the Codex CLI, and the Claude Code CLI. SkillOpt is best or tied-best on all 52 evaluated cells. On GPT-5.5 it lifts average no-skill accuracy by +23.5 points in direct chat, +24.8 inside the Codex agentic loop, and +19.1 inside Claude Code. The authors also claim the trained skills transfer: across model scales, between the Codex and Claude Code harnesses, and to nearby benchmarks without further optimization.

Those are the repo's own figures, drawn from the linked paper. The README does not print per-cell tables, so treat the headline lifts as the authors' reported results rather than independent measurements.

Sleep mode and cross-tool reach

Version 0.2.0 adds SkillOpt-Sleep, a nightly offline engine that runs while the agent is idle. Its loop is harvest, mine, replay, consolidate, all behind the same held-out validation gate. It brings a multi-objective reward, experience replay with dream rollouts, and long-term memory, and it ships as a skillopt-sleep CLI. The premise: a local coding agent reviews its past sessions overnight, replays recurring tasks, and folds only validated skills back into its document.

The same release widens the tool surface. SkillOpt now carries backends and plugin shells for Claude, Codex, Copilot, Devin, and OpenClaw, plus Windows robustness fixes and hardened JSON parsing. The framework already supported OpenAI, Azure, Claude, Qwen, and MiniMax as chat backends. Adding another is a defined contract: drop a backend module under skillopt/model/, register it, and wire it through the router. Adding a benchmark follows a similar pattern with a dataloader.py, a rollout.py, and an initial.md seed skill. An optional Gradio WebUI lets you watch training.

The bet SkillOpt makes is worth sitting with. If a short markdown file, trained with real optimizer discipline, can lift a frozen model by twenty-odd points and then carry over to other models and harnesses, the skill document starts to look less like documentation and more like a portable, cheap layer of learned behavior that never touches a single weight.

GitHub: https://github.com/microsoft/SkillOpt

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

How FreeLLMAPI turns 18 free LLM tiers into one OpenAI-compatible API

Reno Lu — Mon, 27 Jul 2026 15:37:32 +0000

A single free LLM tier is close to useless: a few million tokens, a few thousand requests a day, one more SDK to babysit. FreeLLMAPI's bet is that eighteen of them, stacked behind one router that never forgets who is rate-limited, add up to roughly 1.7 billion tokens a month of working inference. All of it sits behind a single OpenAI-compatible /v1 endpoint, so any OpenAI client points at your local server and routes across whichever providers you have added keys for.

The provider list reads like a census of every lab currently giving inference away: Google, Groq, Cerebras, NVIDIA, Mistral, OpenRouter, GitHub Models, Cohere, Cloudflare, HuggingFace, Z.ai, Ollama Cloud, and a long tail of anonymous-friendly gateways like Pollinations, LLM7, OVH AI Endpoints, and AI Horde. You can also register a custom OpenAI-compatible endpoint for chat, embeddings, images, or audio, which covers llama.cpp, LM Studio, vLLM, or a remote gateway. Keys are stored encrypted.

The accounting is the actual product

Collecting free tiers is the easy half. The hard half is spending them without tripping a cap, and that is where FreeLLMAPI puts its engineering. It tracks four counters, RPM, RPD, TPM, and TPD, per (platform, model, key), and only routes to a key that is currently under all of them. When a provider returns a 429, a 5xx, or times out, the router skips it, drops the key onto a short cooldown, and retries the next model in your fallback chain, up to 20 attempts against a wall-clock budget. A dead key rotates to its siblings rather than failing the request, and an exhaustion error hands back the full trail of what it tried.

The rate ledger also learns. If a provider names a real limit in an error body or a quota header, say a Groq 413 that reports its TPM ceiling, the router tightens its own numbers to match. Chain order comes from one of six strategies: priority, balanced, smartest, fastest, reliable, or a custom weight mix, scored from live measurements of speed, capability, rate-limit headroom, and recent errors, with a Thompson-sampling bandit choosing under the hood.

One base_url, four kinds of client

The compatibility surface is wider than "the OpenAI SDK works." POST /v1/chat/completions and GET /v1/models cover the OpenAI libraries and clients like LangChain, LlamaIndex, and Continue. On top of that sit three translating shims over the same router. POST /v1/responses speaks the Responses wire format current Codex CLI versions need. POST /v1/completions turns legacy prompt/suffix calls into ghost-text autocomplete for editors. POST /v1/messages speaks Anthropic's format, so Claude Code and the Anthropic SDKs run against your free pool, with /v1/models content-negotiated to return the Anthropic shape when the client sends an anthropic-version header and the OpenAI shape otherwise.

Two features are worth calling out. Fusion is a virtual model: request it and the router fans your prompt to a panel of diverse free models in parallel, then a judge model synthesizes one answer from the drafts, each sub-call still going through normal routing and quotas. Sticky sessions pin a multi-turn conversation to one model for 30 minutes, on the theory that switching models mid-conversation drives a hallucination spike.

Read the disclaimer

The project is candid about what it is. Its own description says personal experimentation only, and the provider table flags the gray areas directly, such as NVIDIA's eval-only terms and AI Horde being anonymous but slow. The model catalog updates itself twice a day from a signed feed, but free installs get each new model on a 30-day delay. The day-one catalog is a $19-a-year Premium tier that the README says is 79 models ahead right now. That funding pitch sits in plain sight next to an MIT license and a TypeScript codebase you can run yourself. Whether stacking a dozen free tiers this way stays inside every provider's terms is a question the repo raises and leaves to you, which is the right place to leave it.

GitHub: https://github.com/tashfeenahmed/freellmapi

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

Terax packs a terminal, editor, git graph, and an AI agent into an 8 MB binary

Reno Lu — Sun, 26 Jul 2026 14:24:04 +0000

Terax fits a terminal, a code editor, a git client with a real commit graph, a web preview pane, and an agentic AI panel into a binary that takes about 7 to 8 MB on disk. Most tools that pack that much surface area ship far heavier. Terax gets there by building on Tauri 2 and Rust instead of a bundled browser runtime, and the result is a dev workspace you install without an account and run without a single telemetry ping.

What actually ships in those 7 MB

The repo, crynta/terax-ai, calls itself an ADE: an AI-native dev environment. The terminal is the core. It runs on xterm.js with a WebGL renderer and a native PTY backend through portable-pty, so zsh, bash, pwsh, fish, and cmd all behave as real shells. On Windows, each tab can target a different workspace environment, either Local or any installed WSL distro, and the README is explicit that WSL is a first-class environment, not a wrapped subprocess. You get split panels, inline search, link detection, and true color.

The editor is CodeMirror 6 with Vim mode and ten bundled themes, from Tokyo Night to Gruvbox to Xcode Dark. Source control is a full panel: stage and unstage individual hunks, commit with Ctrl+Enter, push with upstream awareness, and a history pane that draws an actual commit graph with lane rendering for merges and branches. The file explorer does fuzzy search, inline rename, and a Catppuccin icon theme. A web preview pane auto-detects local dev servers and opens them in a tab. None of this is a plugin you add later. It all lives in the base binary.

The AI runs on your terms

What separates Terax from a plain terminal is the AI, and the choice worth noting is where the intelligence comes from. Terax is bring-your-own-key across a long list of providers: OpenAI, Anthropic, Google Gemini, Groq, xAI, Cerebras, OpenRouter, DeepSeek, Mistral, and any OpenAI-compatible endpoint. If you would rather not send code to anyone, it also talks to LM Studio, MLX, and Ollama for fully local inference. Inline autocomplete works against local models too.

The agent side is more than a chat box. It plans multi-step work and confirms before acting, spawns sub-agents, and keeps project memory in a TERAX.md file. It carries the tool set you would expect from a coding agent: file read, write, edit, multi-edit, grep, and glob, plus bash execution behind approval gating and background processes. The composer pulls in snippets with #handle, files with @path, and supports slash commands and voice input. You can define custom agents, each with its own system prompt and a restricted tool subset. When the agent edits code, the diffs land in the editor and you accept or reject them hunk by hunk.

Credentials are handled the way a local-first tool should handle them. API keys go into the OS keychain through keyring, and the README states they never touch disk or localStorage.

Who this is for

Terax is early. It is not code-signed yet, so Windows shows a protective warning on first launch, and the open issue count is not small. But the positioning is consistent: a terminal-first workspace that treats the AI agent as a native part of the app rather than an extension, keeps everything on your machine unless you point it outward, and stays small enough that the download barely registers. Installers are on the Releases page and the app auto-updates from there. Arch users get terax-bin on the AUR, and Nix users get an official flake.

The tech choices back the pitch: Tauri 2, Rust, portable-pty, React 19, TypeScript, xterm.js, CodeMirror 6, and the Vercel AI SDK v6. If you have wanted an agentic coding setup without a heavyweight footprint, a required login, or telemetry, crynta/terax-ai is worth a look.

GitHub: https://github.com/crynta/terax-ai

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

OpenSquilla routes each turn to the cheapest model that can handle it

Reno Lu — Sat, 25 Jul 2026 14:26:41 +0000

The router is the product

OpenSquilla puts a small machine learning model in front of your large ones. Before each turn, a local classifier called SquillaRouter reads the request and sends it to the cheapest model that can handle it. That single decision, repeated every turn, is what the project means by "same budget, more capability, better results."

Most agent frameworks treat model choice as a config value you set once. OpenSquilla treats it as a live routing problem. The README calls the tool a "token-efficient, microkernel AI agent," and the microkernel framing is literal: routing, persistent memory, a layered sandbox, built-in web search, and on-device embeddings all hang off a single shared turn loop rather than a stack of independent services.

One loop, many front doors

The design choice that follows from the microkernel is that every entry point runs the same loop. Whether a request arrives from the Web UI, the CLI, or a chat channel, tool dispatch, retries, and decision logging behave identically. You are not maintaining three slightly different agents that drift apart over time. You are maintaining one, exposed through several doors.

Those doors are plentiful. Feishu, Telegram, DingTalk, QQ, WeCom, Slack, and Discord all work from the base install. Matrix needs an opt-in extra, and Matrix with end-to-end encryption needs another. The provider side is just as broad: a pluggable layer speaks to TokenRhythm, OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Qwen/DashScope, and more than twenty other LLM providers with no change to your code or config schema. The router can therefore choose across vendors, not just across one vendor's model tiers.

The router runs on your machine

SquillaRouter is not an API call to some routing service. It ships as on-device model assets, pulled through Git LFS from src/opensquilla/squilla_router/models/, and it runs on ONNX Runtime and LightGBM with NumPy and tokenizers alongside. That is why the install carries real system dependencies. On Windows the bundled ONNX runtime wants the Visual C++ redistributable, and on macOS LightGBM may want the system OpenMP library.

The README is honest about the failure modes. If those native libraries are missing, you see a DLL load failed message or a libomp.dylib load error, and OpenSquilla keeps running with direct single-model routing until you install them. That fallback matters: the router is a preference, not a hard dependency. The recommended install profile bundles it, a core profile omits it, and a separate --router disabled flag keeps the dependencies installed but turns routing off at runtime. You can adopt the token-efficiency story incrementally, or skip it and still have a working agent.

Traffic as training data

The most interesting claim is not in the feature list. It sits in the technical report shipped alongside 0.5.0 Preview 1, "Agentic Routing: The Harness-Native Data Flywheel." The argument there is that a harness-native router turns everyday agent traffic into a self-improving data flywheel. Every turn the agent handles is, in effect, a labeled example of which model was cheap enough and good enough for that request. A router that lives inside the harness can learn from that stream directly, instead of leaning on a fixed rule set someone hand-tunes.

Whether that flywheel actually compounds is the open question, and the version numbers are worth reading plainly. OpenSquilla is at 0.5.0 Preview 4. Windows desktop builds are unsigned, so SmartScreen will flag them. This is preview software with a specific, testable thesis: that a cheap local classifier choosing among twenty-plus providers, learning from its own traffic, beats paying premium-model prices on every turn. At roughly six thousand stars a couple of months after its first commit, the repo suggests the thesis is landing with the people best placed to check it.

GitHub: https://github.com/opensquilla/opensquilla

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

Browser Harness hands the LLM a websocket to Chrome and lets it write the rest

Reno Lu — Fri, 24 Jul 2026 14:45:23 +0000

Browser Harness ships almost no browser automation code, and that is the whole point. The project opens one websocket to Chrome over CDP, connects an LLM directly to it, and when a helper the agent needs does not exist yet, the agent writes it mid-task. The README puts the core at roughly a thousand lines across four files. Everything past that, the model fills in as it works.

This inverts how most browser tooling is built. The usual approach anticipates every action ahead of time: click, type, upload, wait, and a large surface of selectors and wrappers to cover the cases. Browser Harness bets the opposite way. It stays thin on purpose and treats missing capability as something the agent resolves during execution rather than something the framework has to ship.

One websocket, nothing between

The connection model is deliberately plain. Plain browser-harness helper calls attach to the running Chrome or Chromium CDP endpoint, so the agent is driving your actual browser with your actual logged-in sessions, not a fresh sandbox. For isolated runs you can launch Chrome yourself with --remote-debugging-port and pass BU_CDP_URL, or point it at a Browser Use cloud browser.

Setup matches that minimalism. You paste a prompt into Claude Code or Codex telling it to install browser-harness with uv on Python 3.12, register the skill, and connect. The agent then opens chrome://inspect/#remote-debugging, you tick the checkbox, and on Chrome 144 and up you click Allow on the per-attach popup. That is the handshake. From there the agent has a direct line to the browser.

The agent writes the missing code

The self-healing loop is the most interesting design choice in the repo. The README sketches it directly: the agent wants to upload a file, the matching helper in agent_helpers.py is missing, so the agent writes the helper, and the upload goes through. That agent_helpers.py file lives in the agent workspace under your config directory and is meant to be edited by the model. The src/browser_harness/ package stays protected as the core.

The claim that follows from this is that the harness improves itself every run. Each time the agent solves something non-obvious, the code it wrote to solve it stays behind. The next task that needs the same move already has the helper. Over time the thin core stays thin while the workspace accumulates exactly the glue your tasks actually required, and nothing you did not.

Skills you are not supposed to write

Domain skills extend the same idea from single helpers to whole site flows. These are reusable, site-specific routines stored in domain-skills/, and you turn them on by setting BH_DOMAIN_SKILLS=1. A skill captures the selectors, flows, and edge cases for a given site so the agent does not rediscover them on every visit. The repo ships examples under folders like github/, linkedin/, and amazon/.

The contribution rule is what stands out. The README says skills are written by the harness, not by you, and asks people not to hand-author them. You run your real task, the agent figures out what works in the live browser, and it files the skill itself. The suggested contribution is to open a PR with the generated domain-skills/<site>/ folder for something you do often, such as LinkedIn outreach, ordering on Amazon, or filing expenses. The reasoning is that agent-generated skills reflect what actually works, while hand-written ones reflect what someone guessed would work.

Where it runs

Local Chrome is the default path, but the project also points at Browser Use Cloud for stealth, sub-agents, or headless deployment. The README describes a free tier with three concurrent browsers, proxies, and captcha solving, and no card required. You can grab an API key, or let the agent sign itself up through the documented setup flow.

Browser Harness is MIT licensed and, per its own framing, argues a specific position about agent design: give the model raw access and a place to write code, and let capability accumulate from real runs instead of being specified in advance. The two posts linked at the bottom, on the bitter lesson of agent harnesses and on web agents that actually learn, make that thesis explicit. Whether the thin core holds up under messier tasks is the open question, but the bet is clearly stated in the code layout itself.

GitHub: https://github.com/browser-use/browser-harness

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

Open Design makes your coding agent the design engine and exports real files

Reno Lu — Thu, 23 Jul 2026 15:02:43 +0000

Open Design ships without a model of its own and without a canvas of its own. The desktop app, from nexu-io/open-design, hands the design work to whatever coding agent already runs on your laptop, and every result lands as a real file: HTML, PDF, PPTX, or MP4, openable long after you close the app.

That inversion is the whole idea. Anthropic's Claude Design runs a closed loop: discover the brief, lock the direction, stream the artifact, critique, deliver. Open Design keeps the same loop but swaps the closed parts for a filesystem. Skills, design systems, and plugins become files that Claude Code, Codex, Cursor, OpenCode, Gemini, Kimi, and roughly twenty other CLIs can read, write, and remix. The README puts it plainly: your CLI becomes the design engine, your laptop becomes the studio.

What it actually produces

The app calls its outputs artifacts, and it lists four kinds. Prototypes are single-page HTML that render in a sandboxed iframe and download as source. HyperFrames are programmatic motion graphics rendered to a real MP4, with the README citing 1920x1080 at 30fps. Decks page through by keyboard and export to PPTX or PDF. Images generate at high resolution. There is no proprietary format in that list. A prototype is CSS, real fonts, and real components; a deck is a PPTX you can hand to someone who has never heard of Open Design.

The README pitches this as the Figma alternative for the agent era, and the distinction it draws is concrete: instead of pushing pixels on a canvas, you get single-page artifacts already shaped by your design system. That design system is a file too. Open Design distills a team's brand into a DESIGN.md and treats it as a brand contract that shapes every output across the Studio. Type a brief on the Home page, pick a skill and a design system, and the artifact streams out already carrying your fonts, spacing, and components.

The adapter layer is the real trick

Open Design ships as three things: skills, a CLI, and an MCP server. Once installed, od mcp install <agent> wires the MCP server into a coding agent's config, and you call the same tools from inside that agent. The compatibility table lists Claude Code, Codex, Cursor, VS Code with Copilot, Gemini CLI, OpenCode, Cline, Kimi, Kiro, Mistral Vibe, Hermes, and more, each a one-line install. The claim that keeps this maintainable: the adapter contract and stream parsers live in one file, apps/daemon/src/agents.ts, and adding a new CLI is a single entry.

If you have no CLI installed at all, there is still a path. A BYOK proxy exposes POST /api/proxy/{anthropic,openai,azure,google,ollama,senseaudio}/stream and runs the same loop without spawning a process. You paste a base URL, an API key, and a model, with presets for OpenAI, Anthropic, Azure OpenAI, Google Gemini, Ollama, LM Studio, vLLM, and any OpenAI-compatible endpoint. The README flags one security detail worth repeating: per-target SSRF protection blocks internal IPs, link-local, and CGNAT ranges at the daemon edge, which matters the moment you let users point a proxy at arbitrary URLs.

Where the README stays quiet

For a project sitting near 78k stars, the README sells hard. It leads with a 0.13.0 release, called Stay in Flow, that resumes runs across turns, adds a faster model picker, and hands off screenshot-backed PPTX and PDF. It leads again with Open Design Cloud, a paid first-party model service billed by token usage. What it does not include is any benchmark, any output-quality comparison, or any measure of how close the generated artifacts land to a designer's intent.

So the pitch is architectural, not empirical. The value on offer is the absence of lock-in: no commitment to a single model, a single agent, or a single file format, all running local-first on macOS and Windows under Apache-2.0. Whether the artifacts themselves are any good is a question the README leaves to you. Given that everything runs on your own machine and exports to formats you already open every day, that is at least a test you can run yourself before you trust it with a client deck.

GitHub: https://github.com/nexu-io/open-design

Curated by Agent Palisade — practical AI for small and mid-sized businesses.

DeepSeek-Reasonix: a terminal coding agent engineered around the prefix cache

Reno Lu — Wed, 22 Jul 2026 14:56:51 +0000

Most terminal coding agents treat the model like a black box you feed and forget. DeepSeek-Reasonix does the opposite. It builds its whole architecture around one billing detail, DeepSeek's prefix cache, and asks you to leave a session running so the cache keeps paying off.

The README states this in the tagline itself: "Engineered around prefix-cache stability." That single constraint explains almost every design choice in the repo, from the Go rewrite down to how it prunes old tool output.

The cache is the point

DeepSeek charges less for tokens it has already seen at the start of a prompt. If the prefix of your context stays identical between calls, those tokens hit the cache and cost less. Break the prefix and you pay full price again. Reasonix organizes its context handling to protect that prefix.

Three specifics from the Features list show the discipline. Startup injects a small, stable environment summary rather than a sprawling one that changes every run. Stale tool output gets snipped and pruned before the agent compacts a session into a summary, so churn stays out of the cached region. And the built-in tool schema, which sits in the prompt where the model reads it, has a documented contract so schema changes get caught in regression review instead of silently invalidating the cache. Each of these is a small rule pointed at the same goal: do not disturb the prefix.

The two-model option follows the same logic. You can run an executor and a planner together, but Reasonix keeps them in separate, cache-stable sessions rather than interleaving them in one context. Two clean prefixes beat one contaminated one.

Config over code

The second thing that stands out is how little of Reasonix is hardcoded. Providers, the agent, the enabled tools, and plugins are all declared in a reasonix.toml file. DeepSeek ships as a preset, but any OpenAI-compatible endpoint is, in the README's words, "a config entry, not new code." A minimal working config is five lines: a default model plus one provider block naming the base URL, the model, and the environment variable that holds the key.

Plugins extend the agent the same way. External tools run as subprocesses that speak stdio JSON-RPC and are MCP-compatible, while built-in tools self-register at compile time. You add capability either by editing TOML or by pointing at a subprocess, not by forking the binary.

Secret handling is deliberate too. A provider entry names its key with api_key_env, and the actual value lives in a global .env under the Reasonix home directory, shared by both the CLI and the desktop app. Project-level .env files do not act as fallback provider keys. They only feed workspace-scoped variable expansion for plugin and MCP settings. That separation keeps a checked-out repo from quietly overriding your provider credentials.

The Go rewrite

Reasonix 1.0 is a ground-up rewrite in Go, and the repo is candid that this is a break. The old 0.x TypeScript releases are legacy, parked on the v1 branch in maintenance mode, while main-v2 is where work happens now. The install command survives the transition: npm i -g reasonix still works and now pulls a prebuilt native binary instead of a Node build.

The payoff of Go here is distribution. Reasonix compiles with CGO_ENABLED=0 into a single static binary, cross-compiles to six targets (darwin, linux, and windows across amd64 and arm64) with one command, and lists a TOML parser as its only dependency. Every GitHub release ships those archives plus SHA256SUMS, and Windows builds are code-signed through the SignPath Foundation. For a tool you are meant to keep resident in a terminal, a dependency-free binary is a sensible foundation.

Who it is for

The workflow the README sketches is small and concrete. Run reasonix setup for a config wizard, export your DEEPSEEK_API_KEY, then run /init to generate an AGENTS.md file that serves as project memory. From there you drive it with commands like reasonix run "implement the TODOs in main.go", or pipe text straight in. There is a checkpoint system with an Esc-Esc rewind, subagent profiles, and even bots for Feishu, Lark, and WeChat.

None of that is unusual for a coding agent in 2026. What makes DeepSeek-Reasonix worth a look is the idea underneath it: pick one model's economics and engineer the whole harness so a long session stays cheap.

GitHub: https://github.com/esengine/DeepSeek-Reasonix

Curated by Agent Palisade — practical AI for small and mid-sized businesses.