That is the one ManyChat feature most creators and businesses actually use. But ManyChat’s free plan now stops at 25 contacts, and one viral post can push you into a paid tier. HushReply does that one job, for free.

What it does

**Instagram and Facebook Pages** from one deployment. **Keyword rules** that ignore the word inside other words and handle emoji, so `LINK🙏` matches but `linked` doesn’t. **Public replies with rotating variations**, so it never looks copy-pasted. **Multiple accounts**, each with its own keywords. **A simple dashboard**: no code, and you can test a comment before it goes live. **Honest replies**: if the DM fails, the “check your DMs” reply is held back.

How it’s built

It runs as one small Worker in your own Cloudflare account, on the free plan, which covers about 500 keyword replies a day at $0. It uses Meta’s official private-replies API: no scraping, no browser automation and no password sharing. There is a one-click “Deploy to Cloudflare” button, and no Meta App Review is needed when you use it on your own accounts.

Under the hood

Each comment follows the same path through the Worker: webhook in, signature check, parse, find the account, find the rule, claim the comment, check the cooldown, send the DM, then post the public reply.

**Answer Meta first, work second.** Meta retries any webhook that responds slowly, so the Worker returns `200` immediately and does the Graph API calls in `ctx.waitUntil`. **Never DM twice.** Every comment id is claimed in Workers KV before anything is sent, so a redelivered webhook is ignored. A self-comment guard checks against every configured account, so two of your accounts can never get stuck replying to each other. **Signatures checked properly.** HMAC-SHA256 against each app secret, because Instagram Login uses a different secret from the Facebook app. **Emoji-aware matching.** JavaScript’s `\b` only understands ASCII, so the `word` match mode uses a hand-written Unicode word boundary. Other modes are contains, exact, starts-with, regex and any comment. **Stable replies.** The public reply variation is picked from the comment id, so a retried webhook posts the same text. **Tokens that don’t expire.** A daily cron refreshes Instagram’s long-lived tokens before their 60-day expiry. **Secrets stay out of `ps`.** The local dashboard only listens on 127.0.0.1 and passes tokens to `wrangler` through stdin or a `chmod 600` temp file, never as command-line arguments.

It ships with `DRY_RUN` on, and 82 unit tests run on Node’s built-in test runner.

To be honest about it: it is not a full ManyChat replacement. There is no flow builder and no broadcasts, and setup takes about an hour, mostly in Meta’s developer settings. But if all you need is “comment a keyword, get the DM”, you shouldn’t be paying monthly for it.

HushReply is open source under AGPL-3.0. Try it from the [website](https://lakpriya1s.github.io/hushreply/) or read the code on [GitHub](https://github.com/lakpriya1s/hushreply).

Agent Rack is an MCP server that wraps command-line coding agents. Claude Code, OpenAI Codex, opencode and Antigravity are built in, and any other CLI agent can be added with a small adapter. Point any MCP client at it, and your main agent can work with the others without leaving your workflow.

What you can do

Delegate quick tasks and get results straight back. Run long tasks as background sessions, and watch progress and live logs. Send follow-up instructions while an agent is running, or cancel it. Connect several profiles of the same agent as separate agents.

The real benefit is another agent’s context, not just another tool call. A sub-agent reads files, runs commands and reasons on its own budget, then hands back a result, so the work never fills your main conversation’s context window.

Structured code review

Agent Rack also does structured code reviews. Its adversarial review mode looks for hidden bugs, security issues, edge cases and release risks, and returns validated JSON instead of free text. The reviewing agent never changes your code; the final decision stays with you.

Built for Claude Code

In Claude Code it installs as a plugin, which adds the MCP server, tools and skills. You don’t need to remember tool names: describe what you want, and Claude Code delegates to the right agent, knowing when to run a quick task, when to start a background session and how to present review results. A terminal dashboard and a guided setup that detects installed agents come with it.

How it works under the hood

Agent Rack never calls a model or asks for an API key. It runs the agent CLIs already on your `$PATH`, with the logins you already have, and translates between them and MCP. It's written in TypeScript on the official MCP SDK, and its layers depend in one direction only: config, security, adapters, engine, tools, server, CLI.

Every agent speaks a different protocol, so each one gets its own adapter:

**Claude Code** streams newline-delimited JSON events, and follow-ups resume the same conversation with `claude --resume`. **Codex** runs through `codex exec` with JSON output and resumes by thread id. **OpenCode** only works interactively, so Agent Rack drives it through a real pseudo-terminal with `node-pty`. **Antigravity** has its own stream format.

Conversation ids are read from each CLI’s own output instead of being made up front, so a wrapper script configured in place of the real CLI keeps working.

Background sessions write to a ring buffer of 512 events with a byte budget. Clients read logs with a cursor that only moves forward, so they can tell when they missed something. Cancelling a session signals the whole process group, first with SIGINT and then SIGKILL (`taskkill /T` on Windows). A separate `cancelling` state keeps the concurrency limit honest while a process shuts down.

Security, stated plainly

Handing your terminal to another agent needs guard rails, and Agent Rack is explicit about which ones it has:

Workspaces are checked by their real path, and a single call can’t raise the execution policy above what the config allows (read-only, workspace-write or full access). Each agent gets an environment allow-list, and variables that look like secrets are stripped. Reviews always run read-only: Codex in its read-only sandbox, Claude Code in plan mode. The optional SSE endpoint, which the dashboard uses, needs a bearer token, accepts only loopback hosts and rejects requests with an `Origin` header, which blocks DNS-rebinding attacks from a browser.

It also says what it doesn’t do: a workspace allow-list isn’t a sandbox, only Codex enforces one at the OS level, and prompt injection isn’t solved.

Try it

# guided setup: detects your agents and MCP clients npx agent-rack setup

# or, inside Claude Code /plugin marketplace add lakpriya1s/agent-rack

# watch every sub-agent live agent-rack dashboard

It registers with Claude Code, Codex, Claude Desktop, Cursor, Antigravity and OpenCode, and prints a snippet for VS Code.

Agent Rack is open source on [GitHub](https://github.com/lakpriya1s/agent-rack) and on [npm](https://www.npmjs.com/package/agent-rack), where it has passed 8,000 downloads in its first year.

What it shows

Model and effort level. Current workspace. Context-window usage. 5-hour and 7-day limits, with the time left until each resets.

The bars change from green to yellow to red, so you can read your remaining headroom at a glance. When your current pace would use up a limit before it resets, ccbar adds a warning with the estimated time. Styles and themes let it match your terminal.

Install

npx ccbar-cli

How it works

Claude Code can run any command as a status line and pipe it a JSON object on every refresh. That JSON already includes the model, effort level, working directory, context-window percentage, cost, and both rate limits with their `used_percentage` and `resets_at` time. ccbar is a single Bash script that reads those fields with `jq` and draws two lines of coloured bars.

{ "statusLine": { "type": "command", "command": "~/.local/bin/ccbar render", "padding": 0 } }

**No network calls and no tokens.** Everything comes from the data Claude Code already passes in, so it’s instant and works offline. **Burn-rate warning.** From how much of a window you’ve used and how long is left until it resets, ccbar estimates whether your current pace runs out first, and when. **Local history.** It caches the last payload for `ccbar stats` and appends a small, throttled history file (at most once a minute, size-capped), so `ccbar history` can draw a 7-day sparkline with estimated cost. **One dependency.** Bash and `jq`. A small Node wrapper exists only so `npx` can install it.

The installer wires ccbar into your Claude Code settings, backing up the file first, and runs a short setup wizard. It is also available as a Claude Code plugin. The code is on [GitHub](https://github.com/lakpriya1s/ccbar).

The problem

Digital transactions grow every day, and so do fraudulent SMS and emails. Traditional detection models are often cloud-dependent, which brings problems with efficiency, scale and especially privacy. Large language models understand language well, but they are usually too heavy for a phone.

The approach

Fine-tune compact LLMs, under 1B parameters, for one task: spotting fraud in unstructured text. Use LoRA and QLoRA so fine-tuning fits modest hardware. Convert to ONNX with Hugging Face Optimum, then quantise to INT8 and 4-bit. Run the models with ONNX Runtime inside a React Native app, fully offline.

Making it run on a phone

Getting a trained model onto a phone took more work than training it.

**Download only what’s needed.** The app reads a model list from GitHub and lets you pick a model and a quantisation level. It then fetches just the config, the tokenizer and that one `.onnx` file from Hugging Face, with resumable downloads and per-file progress. **Tokenising on Hermes.** The JavaScript tokenizer expected a browser, so I patched it to load only local files, rewrote Unicode regexes that Hermes doesn’t support, and added `TextEncoder` and `Buffer` polyfills. **Answer in a few tokens.** The model only needs to say “Yes” or “No”, so generation stops after five tokens, using greedy decoding with a KV cache in ONNX Runtime. The app shows how long each check took.

The results

The fine-tuned, quantised Llama-160M-Chat-v1 reached **99.47%** accuracy with a **168 MB** footprint. The fine-tuned, quantised Qwen1.5-0.5B-Chat reached **99.50%** at 797 MB. Optimised LLMs can deliver accurate, real-time fraud detection on a phone without compromising privacy.

Let’s make AI safer and smarter, right in our pockets.

The app, FraudShield, is live on the [App Store](https://apps.apple.com/app/id6745196395) and [Google Play](https://play.google.com/store/apps/details?id=lakpriya.fraudShield), and the paper is in the [ACL Anthology](https://aclanthology.org/2025.ranlp-1.126/). Thanks to my supervisor, Deshan Sumanathilaka, for his guidance from the first idea to deployment.

Install

npm i react-native-sparkle-ai-chat @react-native-async-storage/async-storage

Use it

Give it a platform, an API key and instructions for the assistant, and brand it with your own name, logo and colours.

import SparkleChat from 'react-native-sparkle-ai-chat';

<SparkleChat platform="openai" apiKey={OPENAI_API_KEY} instruction="You help customers choose from the coffees on our menu." brand={{ name: 'Coffee Assistant', primaryColor: '#FF5C5C' }} />

What’s inside

The library is the chat screen from my [Sparkle AI app](/blog/sparkle-ai-chatgpt-mobile-app), extracted into a package built with `react-native-builder-bob`, so it ships CommonJS, ES modules and TypeScript types.

**Streaming** over server-sent events with `react-native-sse`, so answers appear as they’re written. **History** kept in Redux Toolkit and persisted to AsyncStorage, which is why AsyncStorage is a peer dependency. **Token budget.** Older messages are trimmed so the conversation fits the model’s context window. **Your own backend.** `apiBaseUrl` and `organization` let you point it at a proxy or any OpenAI-compatible endpoint instead of shipping a key in the app, and `completionParams` passes model, temperature and other options straight through.

Tip: for a production app, put your key behind a small proxy and set `apiBaseUrl`. A key bundled in an app can be extracted.

Next: function calling, so users can trigger the app’s own features by asking the assistant, and support for more AI platforms such as Gemini.

It is open source, and contributions are welcome on [GitHub](https://github.com/lakpriya1s/react-native-sparkle-ai-chat).

What it does

Choose the model for each conversation, GPT-3.5 Turbo or GPT-4. Set custom system messages to shape how the assistant answers. Save chats and come back to them later.

How it’s built

Sparkle AI is a bare React Native app (0.71 at launch) with TypeScript, and it calls the OpenAI Chat Completions API directly: you bring your own API key, so there’s no server in between.

**Streaming, word by word.** React Native has no built-in server-sent events, so the client streams completions with `react-native-sse`. Each delta is appended to the message in Redux as it arrives, a stop button closes the stream, and errors appear in the chat instead of failing silently. **Conversations that persist.** Chats are stored in Redux Toolkit with redux-persist on AsyncStorage. Each request rebuilds the conversation from the current chat, with your instructions as the system message, and trims it to the model’s token budget. **Feels like a native app.** Code blocks get syntax highlighting and a copy button, a long press copies any message, voice input uses the phone’s own speech recognition, and a light haptic tap scales with the size of each streamed chunk. **Smooth long chats.** An inverted list is the usual way to build a chat, but on Android it flips with `scaleY: -1`, which is a known source of jank. I patched it to rotate 180° instead.

If you want the same kind of assistant inside your own app, my open-source [React Native chat library](/blog/add-ai-chat-to-a-react-native-app) packages it as a single component.

Download Sparkle AI from the [App Store](https://apps.apple.com/app/id6450364523) or [Google Play](https://play.google.com/store/apps/details?id=lk.codescale.sparkle).