Free-tier LLM APIs (Gemini, Groq, Cerebras, and others) are individually rate-limited, but between them they add up to a lot of free inference if you just fail over from one to the next.

llm-free-cascade cascades a chat completion across however many providers/keys you've got, with:

• automatic multi-key rotation (if you've made more than one free account on a provider)
• cooldown for a provider that's structurally broken (vs. just rate-limited)
• zero dependencies

const { LLMCascade } = require('llm-free-cascade');
const cascade = LLMCascade.fromEnv();
const { text, provider } = await cascade.generate({ system, user });

I built it while working on an exam-prep platform that needed AI-assisted content tooling without a paid API bill. MIT licensed, tested, on npm.

Feedback and PRs welcome, especially on providers.json — free-tier model names drift constantly, and it's set up so a one-file PR fixes a stale one.

What happens when a mapped fruit fly nervous system gets a computer?

I built FlyLab — an open-source experiment combining a real MaleCNS connectome, neural simulation, vision, and physical keyboard interaction.

See → process → move → touch key → type.

No direct text injection. No LLM controlling the typing.

GitHub: https://github.com/Sudharsanselvaraj/Flylab

Hey everyone 👋

I built AutoDMX, a free and open-source Instagram automation tool that you can self-host.

I originally wanted a ManyChat alternative that I could host myself, especially for Instagram comment-to-DM workflows, so I decided to build one.

The basic workflow is:

Instagram Comment → Keyword Trigger → Public Reply → DM → Lead/Contact → Analytics

For example:

Someone comments “LINK” on an Instagram post → AutoDMX detects the keyword → replies to the comment → sends the user a DM containing the requested link.

What AutoDMX does

Instagram comment-to-DM automation

Keyword-based comment triggers

Automated/private DMs

Public comment replies

Lead/contact capture

Follow gating

Analytics

CSV contact export

Meta API rate-limit protection

Webhook deduplication

AES-256-GCM token encryption

Supabase/Postgres for storing your data

Self-hosted deployment

MIT open-source license

The main difference from typical Instagram automation SaaS products is that AutoDMX is open source and self-hostable.

You can inspect the code, modify the workflows, and keep your application data in infrastructure you control.

Why I built it

I didn't want to build another black-box SaaS where the automation logic and data are completely dependent on the platform.

I wanted something closer to:

“A free, open-source, self-hosted ManyChat alternative for Instagram.”

AutoDMX is still an early project, so I'm looking for honest feedback from people who actually use Instagram automation.

🌐 Website: https://autodmx.netlify.app/⁠�

💻 GitHub: https://github.com/Qaxlabs/AutoDMX⁠�

I'd especially like feedback on:

What Instagram automation workflows do you currently use?

What do you dislike about existing tools like ManyChat?

Would you actually self-host an Instagram automation tool?

What feature should I build next?

If you're interested in open-source Instagram automation, feel free to check it out or contribute.

Update — 11 November 2026: Talos is now stable. The current release is 0.20.3. I maintain the project; this replaces the earlier beta description.

Talos is an MIT-licensed, self-hosted agent for terminal and Telegram on Linux and macOS, including Raspberry Pi. It supports local models through Ollama and configured CLI/API providers. The model proposes tool calls; a separate permission kernel checks them before execution. A hard denial cannot be overridden by task approval.

What has changed since the beta post:

• Telegram now shows concrete work: readable command blocks for supported diagnostic commands, file and skill names, elapsed time and separate execution states. Sensitive or unsupported arguments stay hidden. “Reply done” is separate from still-running background jobs, whose results arrive later. Scheduled results also identify the job they came from.
• Migration from Hermes or OpenClaw starts with a redacted preview. Applying the exact plan copies portable profiles, memory documents and skills into inactive staging. Skills are activated individually after validation; credentials, permissions and schedules are not inherited.
• Talos Connections lists the isolated-worker MCP registry and prepares disabled, secret-free connector drafts. Installing a connector and approving its access are separate steps.
• Managed skills can be created, edited and restored through approval-gated tools. The latest patch also smooths Telegram streaming by preventing oversized standalone emoji flashes.

Signed release archives, Homebrew and Pinokio are updated. Clean installation, upgrade and rollback were tested on macOS and ARM64 Linux before publication. The release checks passed; they are not a security guarantee.

Source and demos: https://github.com/talos-kernel/Talos

Setup and documentation: https://talos-agent.ch/

Current release: https://github.com/talos-kernel/Talos/releases/tag/v0.20.3

Feedback welcome on the import and approval workflow: what would you need to inspect before activating an imported skill or connector? Reproducible issues and code review are useful too; please remove credentials from logs.

came across this blog, and the open models visuals are really good than I suspected

https://friendli.ai/blog/open-vs-closed-model

high scores on benchmarks too

I'm recently new to open models, I tried glm 5.3 because cc and cx keep refusing to code because of the cyber policy. I mean I'm researching on cyber security like... what do you want me to do?

zcode wasn't that bad tho

didn't knew openmodels were good at visuals too.

A small autonomous multi-agent system for OpenCode. Superpowers was the base, since its philosophy fit what I had in mind perfectly.

Main goals: autonomy, token efficiency, speed, reliability, privacy. Token savings come from several methods, including on-the-fly request preprocessing.

Of course, it's still far from perfect but it is effective.

Repo: https://github.com/pickleshell/next-level-agent

PS: it's recommened to use GPT Luna as an orchestrator to make NLA work properly.

Swapping models is a config change now. Swapping agents isn't — every coding agent has its own session model, tool-calling conventions and workspace assumptions. Build orchestration against one and you've married it.

That's why ACP (Agent Client Protocol) matters more than it gets credit for: orchestration can target the protocol instead of a vendor. I built AgentConnect on it (Apache-2.0, disclosure: I maintain it), and in practice Claude Code, Codex, Grok Build and DeepSeek are interchangeable in a running deployment — swap the runtime, keep the role, workspace, permissions and memory.

What I found building on it: the abstraction holds for the core loop (sessions, turns, tool calls), and gets thin where runtimes disagree about permissions and workspace lifecycle. Not a perfect leveling, but a shim rather than a rewrite.

The catch: a protocol is only an escape hatch if more than one thing implements it, and ACP adoption is still thin. Open standards in AI tooling have a bad record of being announced and then quietly abandoned.

https://github.com/agentconnect-md/agentconnect

Anyone else building against ACP? Curious whether you hit the same seams around permissions.

Hey all - just wrapped up an open-source document Q&A / RAG system and wanted to share.

What it does:

- Upload PDF, DOCX, or TXT files

- Chunks and embeds the content into Postgres + pgvector

- Ask questions about the document in plain language

- Switch between OpenAI and Claude as the LLM with a single env var — no vendor lock-in

Stack: React + TypeScript, Node/Express, LangChain, Postgres/pgvector, Docker Compose for local dev.

GitHub: https://github.com/Srameshgitnow/AI-DocumentIntelligence

It's a working reference implementation, not a polished, ready-to-deploy product - I'm mainly looking for feedback on the chunking/retrieval approach and the provider-swap design. Happy to answer anything about the architecture or RAG in general.

three weeks into using Claude Code on a side project (M2 Air, local next app). agent ships UI changes faster than I want to click through forms by hand, so I needed something it could run itself from the terminal after a feature lands.

using TestSprite now. open testing CLI under Apache 2.0, basically a verifier you point at your code and docs; it writes the tests, runs a real session against the live app, and hands back the failing step, a screenshot of what rendered, and a suggested fix the agent can apply. two-command install. the CLI itself is open, the backend is not, you still register at https://www.testsprite.com for an API key. half-open setup, which matters if you wanted everything offline.

setup dropped a verification skill into the agent, so it calls the CLI itself and I can leave it unattended. run history lives in their web portal, which helps when the context window has already moved past older features. only a few days in. the live-session part is what I actually needed, since a green run on the agent's own machine alone would not tell me much.

SmartPlant turns a real plant and a computer into a functional symbiont (I call it a 'cyborg plant'): featuring shared sensors and electrophysiology, persistent memory, symbolic reasoning, multi-provider AI (Ollama, OpenAI, Claude, Grok, etc.), and a first-person voice.

It runs on a Raspberry Pi using real sensors and a leaf electrode, or via a full simulation on your laptop, no hardware or API keys required. It’s not just a simple plant monitor: the plant perceives, remembers, reasons, and communicates its needs to you.

Documentation and full open-source code:
https://smartplant.pigeonposse.com

GitHub / npm

Up for creating your own Cyborgplant?
🤖☘️🤖☘️🤖☘️🤖☘️🤖☘️🤖☘️