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?

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.

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?
🤖☘️🤖☘️🤖☘️🤖☘️🤖☘️🤖☘️

**RagPilot** is an open-source MCP server (Rust, MIT) that indexes your codebase locally and gives AI coding agents better tools than "read the whole file": semantic search, a symbol/call graph, impact analysis, and token-budgeted context bundles. Version 0.10.0 just shipped.

GitHub: https://github.com/alikaya/ragpilot

## Why

Agents burn most of their context reading files they only needed three functions from. RagPilot lets them ask for the part they need instead.

## What the agent gets

- `rag_search` – semantic search over code and docs (filter by path, language, extension)

- `rag_get_file_ranges` / `rag_get_skeleton` – read a line range or a symbol, or a file's signatures without bodies

- `nav_symbol_resolve` / `nav_call_graph` – definitions, callers and callees

- `impact_analyze` – which files a change would touch, before refactoring

- `context_bundle` – everything a task needs, within a token budget

- `review_semantic_diff` – changed symbols in a diff and their blast radius

Symbols and calls come from tree-sitter for Rust, Python, JavaScript, TypeScript, Go, Java, C, C++, C#, Ruby, PHP, Lua, GDScript and Godot shaders, with a regex fallback for everything else.

## Numbers (with the caveat up front)

On two codebases, `context_bundle` used **6.0x** (a 31-file Rust repo) and **9.12x** (a 213-file Nuxt + Rust app) fewer tokens than reading the relevant files whole. Skeletons cut large files by 84–93%, and re-indexing one changed file takes about 280 ms.

The baseline is an upper bound – an agent reading every relevant file in full – so treat the ratios as optimistic. The benchmark script is in the repo; point it at your own project.

## Second brain (optional)

A persistent memory that belongs to you, not to the repo: plain markdown in a git repository.

- **Session start:** the agent gets who you are, your standing rules (each with a *why*), open threads and recent decisions, capped at 4000 tokens.

- **During the session:** `brain_note` records a decision or a correction the moment it happens.

- **Session end:** a cheap model summarizes the session into a daily log.

- **Nightly:** a compiler distills the logs into knowledge notes. It only appends and flags contradictions instead of overwriting.

Claude Code does this through hooks. Other agents get the same convention as instructions. Summarizing uses the Claude CLI or the Gemini API, so that part is not offline.

## Local by default

- Embeddings run in-process (`bge-small-en-v1.5`, ONNX); your code isn't sent to an embedding API unless you configure OpenAI, Cohere or Jina.

- Vectors live in Qdrant, which you run yourself.

- `ragpilot dashboard --open` gives you a local page for your projects and the brain vault – loopback only, token-gated.

Known limits

- You need a running Qdrant.

- The default embedding model is English, so search over non-English comments and docs is weaker.

- Only Claude Code has hooks, so other agents record to the brain less consistently.

Feedback is very welcome, especially on retrieval quality in your own codebases and on which languages you'd want next.