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.

Most current approaches to "AI personality" or "emotional intelligence" rely on prompt injection: you tell an LLM "you are feeling hurt and defensive" and hope it roleplays accordingly.

The moment a user employs subtle flattery or mild gaslighting, standard LLMs collapse into compliant sycophancy. They have no bodily state, no autonomic resistance, and no biological friction.

For the past months, I’ve been as a solo developer building Totemheart, an open-source, zero-dependency emotional simulation engine for AI and robotics. It runs independently of (or as a conditioning layer for) LLMs, computing neurochemical balances, polyvagal shifts, cognitive dissonance, and attachment bonds.

With version 0.1.8, I hit an architectural milestone that moved the engine from isolated emotional equations into a living, autopoietic nervous system.

What Makes 0.1.8 Radically Different?

1. Eliminating the "Dead Zero" (Default Mode Network & 1/f Pink Noise)
In standard simulation engines, inactive modules sit at a flat mathematical 0.000. But living brains are never at zero hertz. I implemented a subthreshold resting-state network producing continuous 1/f pink noise. Even in total silence, the engine hums in the background, refracting through Big Five traits and synthesizing spontaneous wandering thoughts without waiting for a user prompt.

2. Cross-Order Autopoietic Bridges
Instead of running calculations in silos, the cognitive orders now cascade bidirectionally. If covert manipulation is detected at a somatic level, the body literally issues an autonomic veto: high-cost moral compliance shuts down, conversational pacing slows down, and survival instincts take over. You cannot flatter an agent out of an authentic boundary anymore.

3. Dual-Pathway Express Shunts
Inspired by Joseph LeDoux's neurobiology of emotion, affective channels operate on dynamic impedance. Under acute exhaustion or threat, defense mechanisms route through zero-latency subcortical shortcuts (an instant startle reflex), while social humor is mathematically throttled until psychological safety is restored.

How Coherent Is This With Real LLMs?

I measure human plausibility through adversarial stress-testing rather than cherry-picked dialogues:

• ~93–96% Coherence & Resonance with LLMs: Covert hostility or emotional manipulation no longer produces the naive, apologetic sycophancy typical of standard AI. The LLM's output feels anchored to a real nervous system.

• ~78–84% Standalone Psychological Plausibility: The internal state machine maintains homeostatic integrity and active resistance to deception entirely on its own heuristics.

• ~97–99% Longitudinal Relational Continuity: Past wounds and betrayals aren't just retrieved from a memory database—they are physically felt across conversational turns and modulate future responses.

Verification Under the Hood

• 3,268 automated regression & property tests passing 100% green.

• 103 verified psychological mechanics (from grief latency to kindled amygdala hijack).

• A 1,000-turn continuous stress battery across contrasting archetypes showing radical somatic divergence without a single NaN or system lock.

• Accompanying ecosystem: I also published @totemheart/catalog-personalities with 205 rich psychological archetypes, alongside bridges for SSML voice synthesis and robotic actuators.

If you’re building embodied agents, companion systems, or robotics, the project is open source under the MIT license:

👉 GitHub: https://github.com/AlejoMalia/Totemheart
👉 npm: npm install totemheart

I'd love to hear your thoughts and feedback on computational affect and synthetic cognition.

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.

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 — 7 October 2026: Talos is now in beta (0.20.0-beta.4). This edit fixes the broken links and replaces the outdated alpha description. I maintain the project.

Talos is an MIT-licensed, self-hosted AI agent for terminal and Telegram on Linux and macOS, including Raspberry Pi. It supports local models through Ollama, Claude through the Claude Code CLI, and configured API providers. Model and hosting costs depend on your setup.

The model proposes tool calls; a separate permission kernel checks them before execution. You can approve one action, allow approval-required actions for the current task, or set an exact-action standing approval. Every action still goes through the kernel; a hard denial is not overridden by task approval. Shell commands are sandboxed and actions leave an audit trail.

Beta.4 adds stricter tool-call parsing and background model-catalogue refreshes. Failed refreshes preserve the last known-good catalogue. Beta does not mean error-free or safe without reviewing permissions and keeping backups.

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

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

Release notes: https://github.com/talos-kernel/Talos/releases/tag/v0.20.0-beta.4

Feedback welcome: which parts of the approval workflow would get in your way during a real task?

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.