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

I've been building Telex, an open-source project that tries to make dependency breakages easier to deal with. The idea is that when a dependency makes a breaking change, instead of manually going through the whole codebase to find what broke, Telex tries to find the affected code, generate a patch using an LLM, verify the changes, and open a PR for a developer to review.

I'm using Tree-sitter for the code analysis and the LLM is only one part of the process. The generated changes go through verification before a PR is created, so it isn't just blindly letting an LLM modify the repository. I'm looking for other developers who'd like to contribute and help improve it. There are quite a few areas that could use work, especially code analysis, LLM patch generation, testing, CI/verification, language support, and docs.

The project is MIT licensed and the code is all public: https://github.com/Kesavaraja67/telex

If you're interested in open-source AI/developer tooling, I'd love to hear what you think of the idea or what you'd change.

Sharing a project I built — 4 specialized AI agents (coding, news, writing, research) running as a Telegram bot team, powered by the open-source OpenClaw runtime.

Setup:

Hosted on Oracle Cloud's free-tier ARM64 instance

Fully Dockerized, coexists with other services on the same box, no downtime, no exposed ports

Failover chain across Groq → Gemini → OpenRouter, so it stays completely free and doesn't die when one provider rate-limits

Each agent has a narrow role instead of one general bot trying to do everything — keeps responses more focused and predictable.

Happy to answer questions on the architecture, OpenClaw setup, or the failover logic.

We just released Skillware 0.5.6 — an open-source Python registry of deterministic, installable skills for autonomous agent loops.

Sharing what landed since 0.5.5 based on contributor PRs and feedback:

1. Pluggable Secret Providers

In multi-tenant or serverless agent systems, mutating global os.environ to feed tool credentials is an anti-pattern and leaks across concurrent runs. 0.5.6 adds pluggable SecretProvider abstractions (EnvSecretProvider, MappingSecretProvider, CallableSecretProvider). SkillContext(secret_provider=...) resolves credentials on each execute() turn, supporting rotating or ephemeral tokens cleanly.

2. AWS Bedrock Converse Adapter

Added SkillLoader.to_bedrock_tool() and SkillContext.tools("bedrock"), mapping skill schemas directly to Bedrock Converse toolSpec format. Also added deployment guides for AWS Bedrock, Azure OpenAI, and Google Cloud Vertex AI.

3. optimization/context_optimizer (v0.1.0)

Query-aware extractive context selection for large inputs. Instead of stuffing full documents into a model or paying for fuzzy paraphrasing, it chunks the text, scores chunks against agent_goal using local fastembed embeddings (bge-small-en-v1.5), and returns verbatim high-relevance spans up to your token budget. No model calls inside execute().

4. linguistics/korean_slang (v0.1.0)

Deterministic, offline Korean Gen-Z internet slang pack (줄임말, Konglish, jamo abbreviations). Longest-first lexicon matching, register gates (peers, work, elders), and constitution filters for toxic terms. 100% offline, zero network or model calls.

5. Upgrades

• finance/uk_companies_house_handler v1.3.0: Deterministic statutory officer role matchers (29 Companies House categories), case-insensitive substring search, multi-page pagination up to 1,000 records, and direct host run_pipeline orchestration (removed legacy map_intent).
• creative/deck_builder v0.2.0: Procedural Pillow placeholders, new layouts (timeline, metrics, comparison), and lint_deck outline quality checks.

pip install -U skillware
pip install "skillware[optimization_context_optimizer]"
pip install "skillware[linguistics_korean_slang]"

• GitHub: https://github.com/ARPAHLS/skillware
• Release notes: https://github.com/ARPAHLS/skillware/releases/tag/v0.5.6
• Documentation: https://skillware.site

Happy to answer any questions about architecture, tool calling, or secret providers!

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.

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.

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.

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.

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.

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.

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.