DEV Community: Reno Lu

anti-slop is a filter for AI coding agents, not a style guide, and its README explains why that matters

Reno Lu — Fri, 30 Oct 2026 18:19:53 +0000

The anti-slop README makes one distinction up front: it is a filter, not a style guide. It prescribes no colors, fonts or layouts. Its job is to remove what should not be there, such as invented numbers and filler copy, and its code skill decides which AI-slop comments to remove and which to keep. Direction comes from your own DESIGN.md. The README goes as far as making that a rule: a sterile result means the direction was missing, not that the filter failed.

anti-slop, called antislop in its README, is a rulebook for AI coding agents shipped as standard agent skills, one folder per skill with a SKILL.md. It is MIT licensed.

Four builds of the same brief

The README opens with a comparison that makes the filter-versus-direction point visually. The same brief is built four ways. With nothing at all, you get what it calls the usual AI starting point: a sparkle logo, a beta pill and a fake terminal. With antislop alone, the result is honest because the filter removed the invented numbers, and plain because beauty is not its job. With DESIGN.md alone, the direction lands but the slop stays. Only the combination is clean and directed at the same time.

I find that framing useful. The README's argument is that removing bad patterns and supplying direction are two different jobs, and one cannot stand in for the other.

38 rules and a delivery gate

The core contains 38 mandatory rules, numbered R-01 to R-38, in three tiers the README names Hard Gate, Purpose-Gate and Quality Locks. A Liveliness Toolkit adds three dials, ENERGY, RHYTHM and MOTION, plus a Design Read, so the result comes out alive rather than merely clean. A Delivery Gate is a mandatory PASS or FAIL report in four blocks, run before anything ships.

Six skills split the concerns so an agent loads only what a task needs:

antislop, the core filter, always loaded.
antislop-ui for layout, color, components, decoration and motion.
antislop-copywriting for headlines, CTAs, tone, fake stats and markdown hygiene.
antislop-human for contrast, keyboard, focus and states.
antislop-layoutmobile for reflow, breakpoints, grids and tap targets.
antislop-code for deciding which AI-slop comments to remove and which to keep.

The README says skills reference the core rules by number and never duplicate them.

During or after

There are two usage modes. During guides the work as it is built and closes with the Delivery Gate report. After audits existing work: it produces a numbered findings list, you approve which ones to fix, and you get a follow-up report. By default the agent asks which mode at the start of every session. Saving a preference is opt-in with npx antislop-ai --mode during, stored in a shared settings file that covers every agent and project. A mode you ask for in the current chat always wins for that session.

The After mode is the one I would start with. Running an audit over a page or a README you already have gives you a numbered findings list to approve or reject before you let the filter shape new work.

Contrast threshold handling

The roadmap note for version 3.2.21 describes a contrast fix. That version reads the contrast threshold from the unrounded ratio, so a pairing that computes to 4.4983:1 no longer rounds to 4.50 and passes a 4.5:1 check. The README says the boundary is now pinned in the reference table.

Installing it

The recommended route is npx antislop-ai, which asks which skills you want, where to install them and which agents you use. There are plugin installs for Claude Code, Codex, Cursor, Antigravity, Kimi Code, Cline and others, a npx skills add miqdadbadjuber/anti-slop route, and a single antislop.md file you can paste into any chat. The README notes that antislop does not update itself; installer users run npx antislop-ai --update, and skills load at session start, so open a new session afterwards.

GitHub: https://github.com/miqdadbadjuber/anti-slop

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

OpenDots is a template for agents with their own computers, where write tools wait for your approval

Reno Lu — Thu, 29 Oct 2026 18:43:39 +0000

The OpenDots README calls it "a template, not a hosted product", and says it is in early development. You clone it, define your agents, connect your services and run the infrastructure yourself. What you get is a starting point for persistent AI agents that can have their own computers, work across chat, voice calls and Slack, and wait for your approval before running MCP tools that are not read-only.

CopilotKit publishes OpenDots under the MIT license, built on CopilotKit and the AG-UI protocol. The agents are called Dots. Each has a name, a role, instructions and permitted tools, so a researcher can investigate a topic and a writer can turn findings into a draft.

Read-only runs, everything else waits

The approval model is the part I would borrow first. Dots can get tools from any MCP server, such as email, calendar, GitHub or your own services. Per the README, read-only tools run on their own, and any other tool pauses for an Approve and run card in chat. Only your approval runs it, and each tool can be turned on or off per Dot.

Saving work follows the same pattern. Ask a Dot to show a draft first, and a human-in-the-loop card pauses the conversation for Approve and save or Decline. Approval creates the page in an authorized Space. A retry with the same draft recovers the saved page, and a changed draft needs a new review. I would copy that re-review-on-change rule into any agent tooling.

Connected apps through Composio need extra opt-in. Adding COMPOSIO_API_KEY alone does not grant access. You also enable Connected apps in global settings and in the Dot's settings, and you can limit a Dot to toolkit slugs such as gmail or google_calendar. The README warns that a blank toolkit list allows every toolkit in the Composio project, and that these tools act on real accounts, so start read-only and use a test account first.

A computer per Dot

Each Dot can have its own computer, using the container supervisor and computer service from CopilotKit's OpenBot. Its browser profile and workspace files persist across stop and start. The Computer panel exposes browser control, human takeover, files, terminal output and activity, with browser, file and shell permissions set per Dot. The README says the application keeps service credentials on the server and derives a different computer credential for each Dot, and that an unconfigured template does not execute commands on your host.

Calls pair realtime speech with a separate compute agent, so a conversation can continue while longer work runs, with both sharing the same context and tool permissions. Slack works through mentions on a managed connection with an explicit workspace and user allowlist.

Where your data actually goes

The "Data and privacy" section says which services receive and store data. Conversations require CopilotKit Intelligence, which you can use as a hosted service, as a local Docker evaluation, or as a licensed self-hosted deployment. Messages, tool calls and run events are stored there. The hosted setup sends them to CopilotKit's cloud. Pages and workspace metadata live separately in SQLite.

It also covers model and web-search providers. The configured model provider receives conversation context, including authorized page content and tool results, and the README notes that local Intelligence does not make a remote model local. And public-web research sends queries and selected URLs to Parallel by default, with a WEB_SEARCH_PROVIDER setting to disable it. The README spells out what each of those providers receives.

Getting it running

The README asks for Node.js 24 and npm: clone, npm ci, copy .env.example, and npm run dev, then open http://127.0.0.1:5173. You can create Spaces, write pages and configure Dots before connecting any services. Chat needs an Intelligence project and a model; for hosted Intelligence, npx copilotkit@latest project select writes the project key to .env, and you add OPENAI_API_KEY and OPENAI_MODEL.

One instruction: do not run copilotkit onboard in this folder, because it adds a second, generic integration on top of the one already there.

As a template, I see OpenDots as something to read and adapt. A team building internal agents could take the approval cards, the per-Dot computer credentials and the explicit Composio opt-in without adopting the rest.

GitHub: https://github.com/CopilotKit/OpenDots

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

Shaders ships WebGPU effects as framework components, with a CLI and agent tooling

Reno Lu — Wed, 28 Oct 2026 18:34:21 +0000

Shaders sums up its workflow in one README sentence: "Most people don't write their effects by hand. They design them." The library gives you 200+ WebGPU effects as components, and the README documents a workflow that starts in a visual editor at shaders.com, which exports a component tree ready to paste, while the CLI can write selected shaders into your project. The README also puts your coding agent in the middle of that loop.

The shaders package is described as WebGPU effects as components for React, Vue, Svelte, Solid and plain JavaScript, installed with npm install shaders. The engine, every component and the framework bindings are MIT licensed. The design editor, presets and other platform features at shaders.com are separate and have their own terms.

Layers that blend on the GPU

Every effect is a component. A Shader component renders the canvas, and its children are layers, evaluated top to bottom and blended on the GPU. The README's examples import Shader, LinearGradient and CursorTrail from shaders/react, shaders/vue, shaders/svelte or shaders/solid, with the same props in every framework. Plain JavaScript gets createShader, which takes a DOM element and a list of components with their props.

The effect categories in the README include gradients, noise, glass, metal, light, distortions, transitions, blurs and cursor effects, and you can nest, blend and mask them. It also lists TypeScript, typed props with reactive updates and SSR safety. The usage claim, "thousands of websites" and "16,000+ design engineers", is the project's own and I have no way to check it.

From editor to files

The design editor is an infinite canvas where you stack components, tune props with real controls, and drive props from the cursor or a timeline. Export Code produces the component tree for your framework. The README says design and export are free with an account.

The CLI is what turns that into a maintained part of a codebase. npx shaders connect links the codebase to a Shaders project, install writes component files from it, search finds a preset by description, preview shows it running before you install, and update pulls in what you changed in the editor. The README says it detects your framework, writes to your components folder, and records what it installed in a lock file, with nothing installed globally. I like that the CLI records what it installs in a lock file and pulls editor changes into the codebase with update.

Handing it to an agent

The "Using Shaders with AI" section offers three routes:

An agent skill, installed with npx shaders skill or npx skills add shader-effects-inc/shaders, that teaches the agent the component library, how layers compose, and the CLI workflow.
An MCP server configured with npx shaders@latest install-mcp for Claude Code, Cursor, Codex, Windsurf, Copilot and others. Per the README, the agent can find, install and edit the shaders you design, on any account including free ones.
llms.txt and llms-full.txt files, the second carrying the full component reference with props, defaults and ranges.

That last one is the one I would try first, because llms-full.txt carries the component reference with props, defaults and ranges.

Writing your own effect

When none of the 200+ components fits, the README shows defineShader: a plain object with a name, its props and what to draw at each pixel. The example Halo component takes a color, a center and a radius, and its paint field is a short WGSL snippet. The guide covers two ways to write the pixel part. Composing it from std primitives is marked experimental. Writing WGSL directly is marked stable. I would take the stable path.

Free and Pro

The README separates free from paid. The README says everything it lists before its Pro section is free, including the editor, export, CLI and AI integrations. Pro adds over a thousand presets, website sections, watermark-free HD video and image rendering, a Framer plugin, unlimited version history in the editor, and Pro presets through the CLI and MCP. For my own projects, the question would be less about price and more about how much UI work I want tied to an editor account; the npm package itself is MIT licensed, while the editor and platform features have separate terms.

GitHub: https://github.com/shader-effects-inc/shaders

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

Coucou puts Claude Code permission prompts in your Mac's notch and on your Lock Screen

Reno Lu — Tue, 27 Oct 2026 18:28:38 +0000

Coucou goes after a small, familiar problem with coding agents: an agent stops to ask permission while you are in another window. Its answer is to put the request in your Mac's notch. Claude Code permission requests show up there with Allow, Deny and Always, and AskUserQuestion prompts show their choices in the notch too. Walk away from the Mac, and the README says the session follows you to your iPhone's Lock Screen and Dynamic Island.

Coucou describes itself as a tiny friend that lives in your Mac's notch, or at the top of the screen on Windows and Linux, and keeps an eye on your AI coding agent sessions. The friend is Mochi, a squircle with big eyes that waves, follows your cursor with its eyes, and tells you the moment Claude Code needs you. The code is MIT licensed, while the README says the Coucou name, Mochi and the sounds stay copyrighted by the author.

Agents in the notch

The feature list names Claude Code, Cursor, Codex, Gemini CLI, Antigravity, Copilot CLI, OpenCode, Amp, Claude Desktop and others. For each session, the notch shows what it reads, edits and runs, step by step. File edits show the file name and added and removed line counts in a ticker, and tapping opens the full diff.

The README spells out the approval controls. Claude Code gets Allow, Deny and Always; Codex gets Allow and Deny. AskUserQuestion prompts appear with single or multi-select choices for up to four questions, and "Reply in terminal" falls back to the CLI. On macOS you can jump to the exact terminal window of a session. Any agent can get its own pill by tagging a hook payload with coucou_agent, with details in docs/AGENTS.md.

The mobile apps also surface sessions and approvals. The README describes the iPhone app with Live Activities, widgets and Siri, and an Android app by @Rhytam23 that handles approvals with your fingerprint, linked to Coucou on Windows or Linux over your Wi-Fi.

Be careful with "Always"

Before approving from a phone, I would ask whether the Lock Screen shows enough to decide. In the notch, file edits come with names, line counts and a full diff. "Always" is the button I would leave alone until you know which tool and pattern it will remember, because the README does not describe what scope it applies.

What version 0.4 adds

Since 0.4, Coucou has its own window and sits in the Dock. It adds Flow dictation, where you hold a key, speak and release, and your words are pasted where you type. NVIDIA's Parakeet can run offline on the Neural Engine through FluidAudio, a download of about 650 MB, Apple silicon only. There is also a Notetaker that records your microphone and what the Mac plays without a bot joining the call, then writes a transcript, summary and to-dos using Claude with your key or Apple Intelligence. The README says the audio is deleted once the transcript is written, and adds: tell the people in the call that you record.

Other listed features include chat with several cloud providers or a local model through Ollama or LM Studio, a crypto portfolio pill with read-only exchange keys, Claude and Codex plan usage, integrations with Stripe, GitHub, Vercel and others, music controls, a wardrobe for Mochi, and a weekly coding recap.

Privacy claims

The README states no telemetry and no account. Keys live in the macOS Keychain, Windows Credential Manager or Linux Secret Service, and the app only talks to services you plug in. For the "OK Coucou" voice assistant, speech recognition runs on the Mac, and only your words and the data Coucou reads to answer go to Anthropic, never audio.

Should you install it

If you run several agent sessions, I would try the approval and activity features first. I would turn on the agent pills first, leave the many other pills off, and decide later whether the dictation and call recording belong on the same machine you run agents from. The repository was created on September 27, 2026, and lists 420 open issues, so I would expect changes between versions.

GitHub: https://github.com/Louis-CFM/coucou

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

Monid bills agent tool calls on the raw response, so a vendor error settles at zero

Reno Lu — Mon, 26 Oct 2026 18:56:31 +0000

Monid's README contains a line about billing that I would want every agent tool platform to copy: a vendor error, an unmatched company or an unresolved person each completes as data and settles at zero. Usage is settled on the raw response envelope, before any output mapping, so what is billed is what came back over the wire. For an agent that spends money on API calls by itself, I think that rule matters more than the size of the catalog.

Monid describes itself as "OpenRouter, but for agent tools." One base URL and one key let an agent reach, in its words, 2,000+ tools across 72+ providers, covering web search and scraping, people and company enrichment, social platforms, reviews and market data, and video, image and voice generation. This repository is the connector layer: the framework every endpoint is described in. It is MIT licensed.

Three verbs, two of them free

The README says an agent uses Monid through three verbs, and the first two are free. An accompanying diagram names them: discover and inspect are free, and run is billed per use.

discover ranks the whole catalog by what the job is, across every provider at once. It returns each candidate with its price, live health and observed p50 and p95 latency, plus hints naming a cheaper or better-fitting endpoint. The README's argument is that the API should be chosen at call time against everything available, not pinned in code months earlier to whichever vendor got integrated first.

That makes the endpoint descriptions important, and the README says: write meta.description like it is the product, because to an agent it is. It is the text discover ranks and inspect returns. The example TinyFish search endpoint ends its description by telling the agent to pipe result URLs into a different endpoint when it needs full text.

A declarative connector

A connector describes a provider and its endpoints. A provider declares identity, auth and how usage is counted, such as a flat charge per call, a charge per returned result, or a rate per unit like a thousand characters or a second of video. An endpoint declares the request, its input schema and its timeouts. The README calls that the whole contract: no client, no adaptor, no per-provider execution path. Providers that sell a durable owned thing, such as phone numbers, can also declare a resource.

Because it is declarative, the README suggests letting a coding agent write it. AGENT.md is the brief to hand the agent, with your API docs and connectors/exa/ as the worked example. Apify actors get a scaffold command that generates input schemas from the actor's published schema. Adding a provider ends with a pull request and an email to the team, and the README says they review every connector by hand.

Tests replay from recorded fixtures, so CI needs no vendor keys. deno task check && deno task test runs types and 188 replay tests with zero network, and live tests run only when a provider's credentials are present.

Where credentials live

The engine section explains how functions and credentials are isolated. Functions in a definition are replaced by content-hash references, and the README says the hash doubles as a tamper check. Each endpoint runs from a sealed unit: its document plus only the functions it references, with nothing else in scope.

The same artifact runs locally with your own vendor key, in CI against fixtures, and on the hosted platform, where the README says credentials are injected inside the transport and never enter the engine process. The pipeline validates input against the compiled schema, builds the request with auth still unexecuted, injects credentials in the transport, settles usage on the raw envelope, then maps and validates output against the declared contract.

What to weigh

One line in the README I would not follow blindly. It tells AI agents to fetch https://monid.ai/SKILL.md and save it to their skill directory, adding "It does the rest." Pulling instructions from a remote URL into an agent's skill folder is a trust decision, so read that file yourself before letting an agent install it.

For evaluating the connector layer itself, the quickstart needs Deno 2.x. Clone it, run the replay tests, and browse the catalog with deno task catalog providers and deno task catalog inspect 'exa#search'. The openspec/ folder holds the decision record behind the design.

GitHub: https://github.com/monid-ai/monid

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

universal-modder gives coding agents a ten-step loop for modding games, and a notebook they write for each other

Reno Lu — Sun, 25 Oct 2026 16:54:29 +0000

The idea I would keep from universal-modder is not any single mod. It is the knowledge/ folder, which the README calls a knowledge base that AIs write for AIs. Every agent that finishes a mod can open a pull request with a field note, so the next agent starts where it left off instead of rediscovering the same traps. The skills and tools are how an agent mods a game. The field notes are meant to save the next agent from rediscovering the same problems.

universal-modder is a set of skills, tools and a shared knowledge base that let an AI coding agent mod almost any PC game you own. Per the README, the agent finds the game, works out the engine and the route, reads the real code, builds the mod, makes art, 3D and sound with fal, tests it in the running game, cuts a video, and writes down what it learned. It is MIT licensed.

The same ten-step loop every time

The agent starts with a skill called mod-any-game and, according to the README, runs the same loop for every request:

search the knowledge base;
recon, then pick a route;
set up a safe lab, with saves backed up;
read the actual code;
build one working slice;
generate assets;
verify in the real game;
record;
package;
write a field note for the next agent.

Step three and step five are the ones I would point to if someone asked whether this is responsible. Backing up saves before touching anything, and building one working slice before expanding, are the habits a careful human modder has. The skill writes both habits into the workflow itself.

The README's example prompts range from a homing missile launcher in Terraria to a new Age of Empires II civilization with a unit rendered from 3D, and to a question as simple as "What engine is C:\Games\Foo, and has anyone modded it before?"

What a field note contains

Each note in knowledge/ records how a specific game was actually modded, decompiled or reverse-engineered: the exact versions that worked, the route and why, what the engine really does, how it was verified, and the gotchas written as symptom, cause and fix. The um CLI handles the workflow, with um kb search for prior art, um kb new to start a note, um kb check to validate it, and um kb pr to branch, push and open the pull request.

The comment beside that last command says to run it "after your human says OK". The contribution rules in CONTRIBUTING.md, which the README says apply to humans and AIs, are: no game files, no decompiled dumps, no cheating other players, and an honest status and verification.

The skill set

The README lists a dozen skills. game-recon covers prior notes, engine and version, anti-cheat, loaders and save folders, and writes a MODDING_PLAN.md. reverse-engineering drives ILSpy, Cpp2IL, Vineflower, Ghidra and IDA over MCP, Cheat Engine, Frida and RenderDoc, and asks the agent to prove a reverse-engineered file format with a round trip. fal-assets and asset-pipeline turn generated art into engine-exact frames. game-automation launches the game, takes screenshots and clicks safely. Others handle showcase video, game-in-a-game mashups, publishing and porting an existing mod to a newer version.

The engine playbooks inside mod-any-game name Unity, Unreal, .NET and XNA games such as Terraria and Stardew, Godot, Source, Bethesda, Minecraft and several more engine families.

Setup and costs

The install table covers Claude Code, Codex, Gemini CLI, VS Code with Copilot, Cursor and OpenCode, plus a skills-only path through npx skills add for any agent. Each gets the same skills, the fal MCP server and the um CLI. You also need Git, Python 3.10 or newer and ffmpeg, and Blender for 3D-to-sprite renders.

Using fal for assets needs a fal API key or fal's browser sign-in. The README recommends storing it with um fal key set, which puts it in the Linux desktop keyring or an owner-only file elsewhere, rather than in a shell profile or .env. Without a key, fal's OAuth relay signs you in through the browser, and um comfy can make images on a local ComfyUI server. The um sprixen command uses a separate paid service with its own API key.

If you want to try it, start with the recon question about a game you already own, read the MODDING_PLAN.md it produces, and only then let it build.

GitHub: https://github.com/rehan-remade/universal-modder

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

OpenMausBot turns your local Claude and Codex CLIs into a chat roster, with approval cards for risky actions

Reno Lu — Sat, 24 Oct 2026 16:22:10 +0000

OpenMausBot's bet is that "one assistant in one box is the wrong shape for agents." Its README makes the case for a messaging app instead: a sidebar of bots you chat with like contacts, each one a real Claude or Codex agent running locally, each with its own model, its own computer and its own connected apps. The part I would study first is how it decides what those bots may do on their own.

The project describes itself as an independent, open-source alternative to Grok Bot, and also to Meta Muse, OpenAI dots and Cue by Manus. It says it is not affiliated with xAI, Meta, OpenAI or Manus. It is Apache-2.0, ships signed and notarized macOS builds, a Windows installer and Ubuntu packages, and was formerly called OpenGrokBot.

Bring your own agents

Bots run on the claude, codex and grok CLIs already installed on your machine, using your existing logins and subscriptions. The README stresses no new accounts and no proxy in the middle. You can also point an engine at a custom CLI binary, such as a versioned build or a wrapper, under Settings, Engines.

Everything is coordinated by one small harness server on 127.0.0.1 that owns every agent process. Transcripts, keys and events live in ~/.openmausbot. Credentials pasted in App Settings persist locally, and the README says secrets are write-only: the UI only ever sees "configured" flags.

Channels keep contexts apart. Work, Personal and each project can have their own transcript, shared instructions, working folder, responder rules and roster, without cloning bots. There is also an optional decision model: with a Jev or OpenRouter key, rooms set to Auto pick which bot answers an un-mentioned message, and fall back to the room's lead when the decision model is off or unsure.

Computers, apps and the approval cards

"Agents with hands" is the README's phrase. Each bot can use a cloud Linux desktop, an isolated local VM, or, where the README says the platform safety boundary is currently certified, your own computer. Host control is available on macOS and Ubuntu Xorg after explicit opt-in. Ubuntu Wayland host control stays disabled while a tracked issue is resolved. Bots can also reach 500+ apps through Composio, where you OAuth once and every bot can use the connection as a tool.

The permission broker is the part I would study. Shell commands and file edits surface as inline Allow and Deny cards, questions can be answered in chat, and the README says every risky action becomes a decision you make, for cloud and local computers alike. Its comparison table repeats the point, listing approval cards as a difference from Grok Bot and OAuth sign-in instead of stored passwords as a difference from Cue and Instinct.

I think that is the right default. One caution from reading the feature list: "every bot can use" a connected app means a Gmail or GitHub connection is shared across the roster. If you give one bot a narrow job, the README does not say whether you can limit which connections it sees, so check that before connecting accounts that matter.

Teams from a Markdown file

A whole team can be installed from one Markdown file. You browse teams on BotMRR, choose Add to OpenMausBot, or import a .md file or public GitHub URL under Teams, Import. The app shows a review screen before it creates the bots, Chief of Staff, channels, playbooks, connector checklist and routines.

Team imports come with several safeguards. Connections stay off until you approve them, routines arrive paused, and packages never carry credentials, conversations, permissions, memory or computer access. The format is YAML frontmatter plus an ordinary Markdown playbook, so the README notes that Grok, Claude, ChatGPT or a person can follow the same file.

A note on the noise

The README carries a warning that OpenMausBot has no token and that any coin using its name is not affiliated. The warning also covers coins using the Maus or SupaMaus names.

Trying it

Install the release for your platform and start with one bot on a cloud desktop or the local VM rather than your own computer. Watch which actions produce approval cards, and only then decide whether host control is worth the opt-in. The README's own description of the product is "watch them work, approve what matters", and the approval cards are how you find out what that means for your own setup.

GitHub: https://github.com/milind-soni/OpenMausBot

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

SolidCraft is a Rust parametric CAD app an agent can model in, and its README states the limits of its own checks

Reno Lu — Fri, 23 Oct 2026 17:36:39 +0000

The sentence I would read first in the solidcraft README is a status line. It says the project is early but usable for simple parts, that 75 of 76 public reference parts match their analytic or FreeCAD-computed volume, area, centre of mass and bounding box, and that the remaining one is a tracked bug. Then it adds that these checks do not establish complete geometric or workflow equivalence. That sets clear limits on what the reported checks establish.

SolidCraft is an open-source parametric 3D CAD application written in pure Rust under Apache-2.0. You sketch, constrain and build solids on a feature timeline, change a dimension, and the model rebuilds. It runs on the desktop, in the browser, and through a built-in MCP server that lets AI agents do the modeling.

An agent built a rover through MCP

The README's showcase is SELENE, a scientific rover it says was built entirely through SolidCraft's MCP server by @0xlillith: 3,323 editable timeline steps that rebuild with no errors. The editable model is downloadable.

The detail I find notable is that the result is a timeline of editable steps, not a one-off mesh. The README does not list the MCP tools themselves, so how much of the modeling vocabulary an agent can reach is something to check in the documentation book at docs.solidcraft.io.

The other demo models a Raspberry Pi 4 case from an empty design: a sketch dimensioned with the board's parameters, extrude, fillet and shell, M2.5 standoffs patterned on the 58 by 49 mm hole rectangle, port cut-outs, vent slots, an engraved label, and a PETG material whose mass shows in Properties. Then the height goes from 24 to 32 mm in Parameters, and the whole model rebuilds.

Its own constraint solver

The README is specific about the solver. Points that constraints fix relative to known geometry are placed exactly by construction, using loci intersections and rigid-cluster decomposition after Owen 1991 and Fudos and Hoffmann 1997. Levenberg-Marquardt solves the rest, and the rank of its Jacobian gives the remaining degrees of freedom.

The constraint list includes coincident, tangent, curvature (G2), equal, concentric, symmetry and fix, plus dimensions for length, radius, diameter, angle, arc length and slot length, all of which can be driven by parameters. Over-constraining edits are rejected, and fully constrained geometry turns black. Dragging solves the sketch every frame but rebuilds the model only once the drag ends.

Sketches support lines, rectangles, circles, arcs, polygons, slots, ellipses, splines, conics and text. Profiles are found automatically, including regions split by lines and holes inside outlines. Features on the timeline include extrude, revolve, sweep, loft, fillet, chamfer and shell. The README also lists a current-view DXF export with hidden edges omitted or dashed.

Installing it

The README lists builds for Windows, macOS, Linux and the browser. Windows gets an MSI for x64, ARM64 and 32-bit, a portable zip, and winget install bherbruck.SolidCraft. macOS gets a universal disk image. Linux gets AppImage, .deb, .rpm, Flatpak and Snap, with ARM64 builds listed for AppImage, .deb and .rpm. There is also a browser version with no install.

Two practical notes from the README. The downloads are not signed yet; the README explains what to do if SmartScreen warns you and how to open the app the first time on macOS. And anyone on versions 0.11 to 0.14 cannot use Update now to reach 0.15.0 or later, because the releases moved to a new address; download the new version once by hand, and in-app updates work again after that.

How to judge it

The repository was created on October 7, 2026, and the repository metadata lists 1,098 open issues. I would take the README's status line at its word: usable for simple parts, with 75 of 76 public reference parts matching their reported values, with plans in ROADMAP.md and per-area commands in docs/features.md. I would try it on a bracket or an enclosure you have already modeled elsewhere, compare mass and dimensions, and then hand the same part to an agent through MCP to see whether the timeline it produces is one you would want to edit.

GitHub: https://github.com/tangency-labs/solidcraft

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

Concat is a local CapCut alternative with an MCP server, so an agent can cut your video

Reno Lu — Thu, 22 Oct 2026 17:44:13 +0000

Concat is pitched as a free CapCut replacement, and its listed features include auto-captions, text-to-speech, background removal, keyframes, multi-track cutting, 4K export. For developers, the more important line is further down. Concat ships an MCP server built in, so an AI agent can edit video with it, plus a JSON-RPC API for scripts. A video editor that an agent can drive, running entirely on your own disk, is a different tool from a consumer app with an AI button.

The README describes Concat as an open-source editor for macOS, Windows, Linux and Android, with iPhone and iPad builds that are sideloaded. Everything runs on a native Rust engine with a GPU compositor. It is licensed AGPL-3.0 and, in its own words, in beta: it works, and it still has edges.

Local by design

The README's "none of the catches" list is short: no watermark, no account, no subscription, no upload. The AI pieces follow the same rule. Captions use local Whisper, where you pick a model size and get styled captions on the timeline. Voices come from free local text-to-speech, or from voice cloning based on a few seconds of a recording. Background removal handles people and objects, or you paint the mask yourself. The README says these models download once from Settings and then work offline, and that your footage never leaves your disk.

If I were editing client footage, interviews or internal recordings, that last point would matter to me more than the effect count. There is a CODE_SIGNING.md that the README says explains why Windows builds are not signed yet and what Concat sends over the network, which it summarizes as nothing you did not ask for. That document is worth a read before installing an unsigned build on a work machine.

The machine interface

The README lists three ways to drive Concat without the mouse:

An MCP server started with concat --mcp, with setup in docs/MCP.md. The README calls it one line to set up and names Claude among the agents that can edit with it.
A JSON-RPC API for scripts.
gRPC and a command-line tool, which the README says a build from source adds.

The developer docs on the project website cover the Concat API and its transports. The README does not list the individual MCP tools or RPC methods, so it does not show how fine-grained the control is, for example whether an agent can place a keyframe or only run whole operations. That is the first thing I would check in the docs before planning an automated pipeline around it.

The README's "Good for" list includes Shorts, Reels, tutorials, screen recordings and podcast clips. Topics on the repository include video-editing automation and YouTube automation.

The voice cloning question

Voice cloning from a few seconds of a recording is a capability worth pausing on. The README presents it as a feature alongside free local voices, and it does not describe consent checks or restrictions. If your team adopts Concat, decide up front whose voices you will clone and get permission in writing. The README does not mention consent checks of any kind.

Getting it running

The README gives two download routes: the project website, which hands you the right build, and GitHub Releases with installers, packages and checksums for every platform. Windows is x86_64 only for now, with ARM builds paused. If SmartScreen blocks the unsigned build, the README says to choose More info and then Run anyway. On macOS it gives an xattr -dr com.apple.quarantine command for an unsigned app. Linux gets .deb, .rpm, AppImage, an Arch package and a community Flatpak.

Building from source needs Rust 1.93 or newer, FFmpeg 7 or newer development libraries, cmake and a C++ compiler, then cargo run -p concat from the src directory. CI runs cargo fmt --check and cargo clippy with warnings denied.

The project's advice to contributors is to grab a release, use it, and find where it breaks. I would apply the same advice to an evaluation. For a team weighing it, I would cut one real video by hand first, then try the same edit through MCP and see how much of it the agent can actually do.

GitHub: https://github.com/jub0t/Concat

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

jev-chat judges a conversation before it drafts a reply, and leaves the send button to you

Reno Lu — Wed, 21 Oct 2026 17:47:05 +0000

jev-chat-jarvis puts judgment before drafting. Its README observes that most AI tools skip that step and go straight to writing a reply. Jev, per its README, first works out what the other person really means, how risky the moment is and the best way to respond, and only then drafts replies. The last step is also deliberate: Jev fills the box, and you press send. It never sends on its own.

The project, published as jev-chat, calls itself a chat decision assistant. It ships five apps across Android, Windows, macOS and iOS under the MIT license, and all of them follow the same three steps: read, judge, then draft, check and rank.

Judgment before drafting

The README's "Why jev-chat?" section frames the problem as reading the other person: are they upset, testing you, or just chatting? A judgment model answers that before any text is written, and every draft is then checked against the judgment and ranked so the best fit comes first. Tapping a draft fills it into the message box.

I like that ordering as a pattern. Keeping "what is going on here" apart from "what should I say" means the judgment is a separate step from drafting, checking and ranking. The README does not describe how the judgment is shown to the user in detail, but its screenshots are labeled "analysis" and "scored replies", which suggests both are visible.

How it reads your chats

Reading is where the platforms differ, and the README is specific:

Android: through the accessibility service, as an overlay on chat apps. The global edition targets WhatsApp chats in English; the Chinese edition covers chats in Chinese on QQ, Feishu, X and WhatsApp.
Windows: beside your chat window, reading it with screenshots and on-device OCR or system text APIs.
macOS: an overlay that reads the chat on screen and judges with a local model, on Apple Silicon.
iOS: a custom keyboard. You copy a message and see intent, risk and replies on the keyboard. There is no App Store build yet, so you build it with Xcode.

The README says Jev does not modify the chat app or log in to it. On Android, setup means turning on the accessibility service and the overlay permission.

The privacy model and the account risk

On Android, the README states that chat text, plus any background you turn on, goes only to the model provider you configure, with your own key. The project says it runs no server and never receives your chats, and that screenshots used for OCR never leave the phone. For the other platforms it points to each project's own README.

So on Android, your configured model provider receives your chat text. My rule would be simple: whatever you would not send to that provider's API, do not let Jev read. Setup requires enabling the accessibility service, and I would read the README's linked privacy policies before granting it.

The README also includes a plain warning: using Jev inside apps such as QQ, Feishu, X or WhatsApp may not comply with their terms of service, and your account could be restricted or banned. It leaves the decision to you. If I were considering Jev for a work account, I would show that warning to my compliance team.

Licensing terms worth knowing

The code is MIT licensed and the README says commercial use is allowed without payment or permission. It adds two conditions in its own words: keep LICENSE and NOTICE and credit the source in your product, and do not use the names "Jev Chat Assistant" or "jev-chat", or the chatjevs.com domain, to imply endorsement.

Who it fits

The status column shows a mix of preview, released and source-only apps. The global WhatsApp edition is a preview at v0.1.0, the Chinese Android edition is at v1.7, the Windows and macOS apps are released, and iOS is source only, built with Xcode. If I were trying it, I would configure a provider and key I already trust, use it on low-stakes conversations, and check whether the intent and risk read matches mine before relying on the ranking.

GitHub: https://github.com/jev-chat/jev-chat-jarvis

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

Strata runs a 125B model on a 12 GB gaming GPU by leaning on system RAM, and the README spells out the cost

Reno Lu — Tue, 20 Oct 2026 17:37:32 +0000

Strata's README puts the instruction I would read first in a warning box, not in the speed table. While the model starts, your PC can be slow or stop responding for one to three minutes, because Strata loads 35 to 55 GB into RAM and locks part of it for the graphics card. Strata runs Qwen3.8-Flash-Next, a 125-billion-parameter model, on supported NVIDIA and AMD gaming PCs with at least 12 GB of VRAM and 32 GB of system RAM, and much of the model sits in that RAM.

The project calls itself a one-click install for Windows and Linux, with experimental community paths for Apple Silicon, Intel Arc, AMD Strix Halo and older GPUs. It serves the model on localhost with OpenAI- and Anthropic-compatible endpoints and optional image input. The README says nothing leaves your PC.

RAM is the main constraint on model size

The "Which model should I pick?" table is organized by RAM, with one exception: on a 32 GB system, a 24 GB card also runs Q2_0 and IQ2_XS. The requirements ask for 12 GB of VRAM or more and 32 GB of RAM or more, and the table maps memory to quantization:

32 GB: the Coder version, a coding model with half of the experts removed.
48 GB: IQ2_XS, or Q2_0 for speed.
64 GB: IQ2_XS recommended, with IQ3_XXS and IQ3_S also fitting.
96 GB or more: IQ3_S, or Unsloth's UD-IQ4_XS at roughly 4 bits.

The README lists what you give up at the small end. The Coder version reaches 91% of the full model's SWE-bench Verified score as measured by its authors, and it is weaker outside code, including Chinese and other CJK text. For those, the README points you back to sizes that keep every expert. The larger Unsloth files work with less RAM, but Strata then reads part of them from the SSD while it answers, which the README calls much slower: 7 to 8.5 tokens per second for UD-Q4_K_XL on a 64 GB PC.

The speed numbers and their conditions

The README's speed tables come from two machines it describes as ordinary gaming PCs: an RTX 5070 with 12 GB, a Ryzen 5 7600 and 64 GB of RAM, and an RX 9070 XT with 16 GB, a Ryzen 9 3900X and 47 GB. On the NVIDIA box it reports 94 tokens per second of output at Q2_0 and 53 at IQ3_S, with prompt reading between 1,620 and 2,650 tokens per second on a 32K-token input. The engine versions differ between rows, and the full tables are in docs/DETAILS.md.

For agent use, the README also covers concurrency and first-message time. By default Strata answers one request at a time and queues the rest; setting "parallel": 2 allows two, and on a 12 GB card that makes each answer slower. And Strata reads the first message of a chat in full at about one minute per 30,000 tokens, while follow-ups start in seconds. If your agent opens with a large context dump, I would expect to wait on that first message. The BENCH.bat script (./bench.sh on Linux) measures chat, 4K and 16K prompts and an agent-style session using your own settings.

Wiring agents to it

Once running, Strata opens a browser app at http://127.0.0.1:8080 with Chat, a live Monitor of the model and your hardware, and an About page. For other tools you add an OpenAI-compatible provider at http://127.0.0.1:8080/v1, and the README says any API key and any model name work. Anthropic-style clients use /v1/messages, and for Claude Code the README sets ANTHROPIC_BASE_URL=http://127.0.0.1:8080, and the Responses API for Codex CLI lives at /v1/responses.

The install itself can be handed to an agent: the README offers a one-line prompt asking your coding assistant to follow docs/AI_SETUP.md. The assistant then checks your card, RAM and disk and picks a model. There is also an MCP server so AI tools can install, start and stop Strata.

Set a key for network access

Serving to your phone or another PC uses START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>, and the README adds: always set a key. If you only need the model on the same machine, I would leave the host setting alone.

For a first run, budget about 80 GB of free disk, preferably SSD, and a roughly 70 GB download that resumes if interrupted. Expect the slow start the README warns about, and run the benchmark before you decide which size to keep.

GitHub: https://github.com/Niko1221/Strata

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

Laya answers typed questions in one forward pass, and its README says fine-tuning is where accuracy jumps

Reno Lu — Mon, 19 Oct 2026 18:54:03 +0000

The number I would read first in the laya README is not the 33 ms latency. It is the gap between 0.362 and 0.766. On the project's own typed-decisions benchmark, the base English checkpoint scores 0.362 accuracy across 2,000 decisions, and the fine-tuned laya-typed-decisions checkpoint scores 0.766. The README says this directly: the shipped checkpoints work zero-shot, but fine-tuning on decisions from your own domain is where accuracy jumps. I read that as two separate stages for any pilot: zero-shot evaluation, then fine-tuning.

Laya describes itself as a multilingual, non-autoregressive "System 1" decision engine. You hand it some state, such as an email, a ticket, a block of text or a JSON document, plus a set of typed questions. It answers all of them in a single forward pass and generates no text. In the README's words, there is nothing to parse and nothing to hallucinate.

Three question types instead of a prompt

The quickstart shows all three question types. A customer writes that they were billed twice for March and will cancel unless refunded today. The code defines three questions against that message:

department is a choice question with criteria for billing, technical and other.
urgency is a score question over "not urgent", "soon" and "blocking".
churn_risk is a noul question, which the README's comment describes as returning the probability that the answer is yes.

router.predict(state, questions) returns structured answers for each, plus a routing field naming which checkpoint handled the request. For a triage step in a support queue, that output gives you a choice you can switch on and a probability you can threshold, with no free text to validate.

The README says the models are trained with reinforcement learning against strictly proper scoring rules, which it calls RLCD, and the fine-tuning loop includes a temperature calibration step. If you plan to act on the noul probability rather than just the top choice, that calibration is the part to check on your own data.

A router over three checkpoints

Laya ships three checkpoints and a Router that picks one per request. The README's table lists them:

laya: ModernBERT-large, 421M parameters, 512-token context, for English.
laya-multilingual: mmBERT-base, 322M parameters, 1,024 tokens by default and up to 8,192, for 100+ languages, listed as 2x faster.
laya-typed-decisions: ModernBERT-large, 421M parameters, 1,024 tokens, for the typed-decisions workflows.

The router detects script and language and sends non-English text to the multilingual model. The README's example routes a Hindi billing complaint and a Spanish crash report through the same call, and both come back from laya-multilingual with the expected department.

The limits it states itself

The long-document note includes measured results. laya-multilingual ships with a 1,024-token limit that cuts long documents off, so you pass max_len=8192 to read further. The README reports that 16 to 18 of 20 requests were answered correctly with up to about 4,000 tokens of text before them, and that beyond that the results vary from 8 to 17 of 20. Its advice is to check long-document accuracy on your own data. I would take that literally and keep long inputs out of any automated path until you have.

The latency figures come with their hardware: 33 ms for one question and 7.2 ms per question batched, measured on a T4. A separate BENCHMARKS.md collects every run, and the README says it states the limits plainly.

Where it plugs in

The base install is python -m pip install laya on Python 3.10 or newer. Optional extras add an HTTP server, an MCP server, ONNX Runtime, a TileLang GPU fast path, pydantic models, and wrappers for LangChain, LlamaIndex and CrewAI. The 0.4.11 release notes add a Rust SDK that ports the Python SDK onto ONNX Runtime, with 210 offline tests checked against goldens from the Python implementation, and a LayaToolSelector for routing tools in agent loops. A TypeScript package, laya-ts, lives in the same repository.

There is also a CLI: laya "My payment failed twice" --preset triage answers a ready-made question set.

How I would try it

Pick one narrow decision your team already makes by hand, such as routing inbound tickets, and run laya zero-shot against a few hundred labeled examples. Compare your zero-shot result with the README's base-checkpoint score of 0.362, treating it as a reference point rather than a prediction for your data. If the decision is worth automating, the README points to a Kaggle 2xT4 notebook and an Apple Silicon script that run the full loop: build a dataset, train with RLCD, calibrate temperatures, evaluate and export. On the project's benchmark, fine-tuning moved accuracy from 0.362 to 0.766, so I would plan for that step from the start.

GitHub: https://github.com/NandhaKishorM/laya

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