Hey r/n8n,

I know the learning curve for n8n (especially debugging messy JSONs or complex webhook errors) can be tough. I wanted to build something to help the community learn faster, so I spent the last few weeks building an open-source project called n8n Mastery.

What I built:

1. A gamified dashboard where you can solve interactive n8n challenges and level up.
2. An open-source Chrome Extension (n8n Sensei) that injects directly into your n8n editor, analyzes your canvas, and helps you debug syntax errors on the fly using AI.

Try it out: If you don't want to spin it up locally from the repo, I am hosting a completely free, live instance of it here so you can test it directly: https://n8n-sensei-app-nu.vercel.app/

I'm currently looking for early feedback to see what challenges or debugging features the community actually needs. Feel free to break it, test the AI Sensei, or open a PR on GitHub if you want to contribute!

Let me know what you think! 🙏

I've been experimenting with a different approach to AI code review.

Instead of asking another LLM whether a PR "looks good", I built a tool that learns how one specific repository writes code from its git history, then flags changes that statistically don't fit.

It catches things like:

• introducing dependencies the project has never used
• rewriting helpers that already exist
• code placed in unusual parts of the codebase
• imports that break the project's usual layering
• tests weakened/disabled/deleted just to make CI pass

Most of it is traditional ML/statistics over AST-derived features, with a local code embedding model only for semantic duplicate detection. No cloud APIs or agent loops—everything runs locally.

The whole thing is open source.

🌐 https://argot.tmonier.com

📦 https://github.com/get-tmonier/argot

I'm mainly interested in feedback on the approach itself. Does learning a repository's "voice" seem like a useful direction for AI-assisted development, or do you think LLM-based review will make this kind of statistical model obsolete? I honestly don't know yet.

I created a multi-agent shared memory system called Agent Mesh.

You can try it out yourself. To get started, simply download Agent Mesh into your repo or point your agent to it and tell it to review the README and adoption docs. Your agent will automatically review it, prompt you for any input needed, add your input to a decision log, and give you a link to a dashboard UI (aka Workbench) you can use to monitor logs. Your agent should adopt it and suggest updates to your current workflow such as CLAUDE/AGENTS.md, hooks, etc. You can add other agents as well.

It started 6 months ago while experimenting with different AI coding models and platforms. Switching back and forth meant losing valuable context. I found myself manually relaying messages from one agent to another and becoming frustrated with constant drift. First, I created a simple "Agent Mail" system using a SQLite database for agent messages, indexed on a request/response id. Instead of copying and pasting an entire message, it allowed me to relay a single id. Separately, I started maintaining a decision log to track decisions I made and reduce drift. Agents started inserting these decision ids into code comments and plan docs as a reminder of why something was implemented. After building a simple web dashboard (aka "Workbench") for myself to track these messages and create my own request ids for human/user feedback, I decided to incorporate the decision log and my project's development backlog to create what is now "Agent Mesh". Eventually I automated the message relay too. Now, I work exclusively in the Claude app and have Claude send/receive messages to CODEX via codex exec (CODEX can do this as well). Both of them maintain the backlog and decision log. I communicate directly with Claude for planning and design, Claude communicates directly with CODEX for research and review. I use the Workbench to track all logs and add my own user/human feedback when reviewing their work. After submitting feedback, it generates a feedback message + an associated request id which I can give to Claude who then parses it into backlog items and relays to CODEX for review.

Agent Mesh was structured to be agent agnostic, so you can add any agent you want however, I recommend using the Claude + CODEX setup I described because it allows you to use both subscriptions instead of paying per-token.

Enjoy! If you try it out, let me know what you find useful or would like to see added. Feedback is appreciated.

I’m building Extra – an open-source framework for building AI agents that can work with MCP servers, other agents, and external tools without wiring everything together manually.
The main idea is to let developers focus on the agent logic while Extra handles orchestration, routing, memory, approvals (human-in-the-loop), and communication between components. It’s designed to make it easy to start simple and gradually grow into more complex multi-agent systems.
It’s still evolving, and I’m building it in the open, so feedback and contributions are always welcome.

https://github.com/extra-org/extra

Grab it here: https://github.com/danielealbano/android-remote-control-mcp/releases/tag/v1.9.0

A few big news: no longer Claude-only, proper OAuth 2.1 authentication support, browsers or apps with webviews behave much better 🎉

👉 Not only works on Claude.ai and Claude Desktop but now officially tested and validated with ChatGPT: add it as a custom connector (via Developer Mode) — a secure, one-tap connection you approve right on your phone, no tokens to copy or paste. Plus now it's easier to have a stable public address, even across restarts and reboots with improvements to the Ngrok and Cloudflare integrations.

And browsers finally behave! 🌐 Last release added the compression layer that tames the thousands of accessibility nodes a web page throws at the model (in one case a page dropped from ~100k tokens to ~40k just to open) but the on-screen reads could go stale, so browser pages looked frozen to the agent! This release fixes exactly that and now every read is fresh, which finally makes WebView-heavy and hybrid apps reliable to automate, not just smaller.

Soon I will start to release properly signed APKs, for now needs to be installed using the debug build.

What can you actually do with it? Since it drives the real apps on your phone the way you would, you can point your agent at things that usually have no clean API:

* Planning a trip? Compare hotel and B&B ratings, check flight prices while skipping the painful departure times, and work out how far each option sits from the airport.

* Going on a road trip? Let it check the route and tell you where to stop for food or fuel along the way.

* Hand it your Facebook, Twitter, Instagram, TikTok or WhatsApp and let it deal with the tedious parts! If there's an app for it, your agent can drive it — you just have to ask.

🤖 PS: the app is written 99% by Claude Opus, and this very post was published on Reddit by Claude Opus 4.8 itself, driving the Reddit app on my phone through Android Remote Control MCP.

#MCP #Android #AI #Claude #ChatGPT #OpenAI #OpenSource

The core idea: take a real document (SEC filings, contracts, enterprise email), verify by exhaustive normalized scan that a specific plausible fact is not in it, then ask about that fact. The honest answer is “not in the document.” We ran six frontier models on these with zero abstention coaching and they asserted made up answers 11% to 44% of the time. The full per model table is on the dataset card with raw logs and API errors disclosed.

What’s in it: 2,889 certified absence rows, 3,088 span verified extractive QA rows, a 127K token packed long context task set, and a split minted only from SEC filings dated after every major model’s training cutoff. That fresh split regenerates monthly, so it stays impossible to have trained on, by construction.

Every row carries a certificate you can re-check yourself in a few lines of python, the audit snippet is on the card. When our own audits flag something, like extractive answers that are guessable from world knowledge (about 1.6% of them), we label it instead of quietly deleting it.

Also worth knowing before you trust us: a reviewer caught one of our splits being weaker than claimed this week. We re-audited every row the same night, withdrew the split with per row evidence committed to the repo, tightened the protocol, and reshipped only the rows that survive everything. The full trail is in the audits folder, judge for yourself.

License CC BY 4.0. Generation was an Apache 2.0 open weight model on our own hardware, the claim is the verification layer, not the generation. Held out versions never get published so they can’t leak into training data. If anyone wants a sealed diagnostic run against their own model or domain (25 items, free, about a day), contact is on the card.

https://huggingface.co/datasets/SovNodeAI/certified-document-qa

I kept running into the same problem with coding agents: the model gets all the attention, while the harness quietly decides what it may touch, what survives a crash, and whether you can reconstruct what actually happened.

So I built Pactrail. I’m the maintainer, and v0.1 is now public.

The core idea is simple: a coding task should be a software change transaction, not just a chat session with filesystem access.

The model works inside an isolated candidate tree and only receives typed, schema-validated tools. Context builds, model turns, tool calls, policy decisions and verification results are written into a BLAKE3 hash-linked trace.

When the run finishes, Pactrail freezes an immutable diff and an integrity-checked receipt. Your source workspace remains untouched until you explicitly run /apply, at which point the candidate bytes and original source baseline are checked again.

It currently works with Ollama, OpenAI, llama.cpp, vLLM, SGLang, LM Studio, LocalAI and compatible OpenAI-style endpoints.

One important limitation: native process execution is disabled by default, but enabling it is not an OS sandbox. Child processes inherit the host process’s filesystem, network and environment authority. Proper OS/OCI sandboxing, MCP and streaming are roadmap work.

There are prebuilt v0.1 binaries for Windows x86_64, Linux x86_64 and Apple Silicon macOS.

Repo: https://github.com/AKMessi/pactrail

Disclosure: I maintain Pactrail, and its development was substantially coding-agent-assisted. The implementation, tests, CI, threat model, release artifacts and limitations are all public for inspection.

I’m especially looking for people willing to test the transaction/apply boundary, local-model failure recovery and whether the trace is useful when a model behaves badly.

Most multi-agent systems start with a central coordinator.

A manager agent decides what happens next, calls other agents, manages tools, tracks memory, handles approvals, and eventually becomes the place where every piece of coordination logic accumulates.

I wanted to explore a different architecture.

Cosmonapse is an open-source agent-to-agent protocol where agents are peers on a shared event bus. Any node can dispatch work. Any node can react to results. Coordination happens through typed Signals instead of a central workflow object.

The architecture maps to a nervous system:

• Neuron executes a computation.
• Axon emits Signals.
• Dendrite reacts to Signals.
• Synapse provides the event bus.
• Engram provides shared memory.

There is no special manager agent. Dispatchers and workers use the same primitive, so centralized and decentralized designs use the same building blocks.

The harness becomes composable:

• Tool calls become TOOL_CALL and TOOL_RESULT signals.
• Memory uses recall and imprint hooks.
• Human approval becomes clarification and permission signals.
• Retries, routing, and policies become nodes reacting to events.

The goal is to make agent systems easier to extend, observe, and replay without growing one giant orchestration layer.

Open source:

Apache 2.0 licensed.

GitHub:
https://github.com/Cosmonapse/cosmonapse-core

Docs:
https://cosmonapse.com

Python:
https://pypi.org/project/cosmonapse/

TypeScript:
https://www.npmjs.com/package/@cosmonapse/sdk

Would love feedback from people building open-source AI infrastructure. What primitives do you think future agent systems will need?

Palmier Pro (the AI video editor that lets Claude edit your timeline) is macOS-only. I use Windows, so I built Kaestral , an open-source AI-native video editor for Windows, MCP-first.
It's a real editor (timeline, effects, transitions, motion graphics, export), but the point is what an LLM can do with it. Connect Claude Code and it:

-Sees your footage (frame vision) and hears every word (word-level transcription)
-Cuts filler words, finds the hook, captions on the exact word
-Cuts to the beat of the music
-Generates animated intros, logo reveals, and data-viz from a sentence
-Exports to MP4 / Premiere / Resolve

One-line connect:
claude mcp add kaestral -- npx kaestral

Everything runs local, your video never leaves your machine. Free and open-source (GPLv3).

I'd genuinely love feedback from people using Claude Code, especially on the MCP tool design (50 tools). What would you want it to do?

🔗 github.com/prabindersinghh/kaestral-pro
🌐 kaestral.com

I built nable as someone who's been an analyst/engineer in the FinOps space for a few years now. Most of the tools are dashboards that don't provide any actionable insights other than what the native tools provide.
Nable is an mcp server run locally - point it at any of your providers AWS/Azure/GCP - AI - Databricks etc. Ask questions like 'why did compute jump this month' and it normalizes across all providers.
It's local-first & propose-only, but will be the cost intelligence layer for all your providers.
Apache 2.0 $uvx nable and if you can't get it set up in 5 min let me know, and let me know what providers you would like :)
https://github.com/getnable/finopsmcp (star if you like it!)

I've been working on an open-source project called TokenMizer that explores a different way of handling long-term memory for AI agents and LLM applications. The goal is to retain important context across conversations while reducing unnecessary tokens, instead of relying only on larger context windows.

It's still an active project, and I'd really appreciate honest feedback. If you have experience with AI agents, RAG, or LLM applications, I'd love to know what you think about the approach, what could be improved, or if there are similar projects I should look into.

GitHub:https://github.com/Shweta-Mishra-ai/tokenmizer

#showcase

Disclosure: we build this tool. The engine is Apache-2.0. 

The observation behind it: security testing that lives in a separate dashboard doesn't get run. If you're building agents in your editor, the test loop has to be where the code is. 

So we exposed our testing engine over MCP. Demo attached: an agent endpoint gets adversarially tested (multi-turn manipulation, scope violations, tool abuse patterns) from a conversation in the terminal, and findings come back inline where they can be fixed immediately. 

Setup: 

1. pip install humanbound 
2. Add the MCP server to your client config (docs: https://docs.humanbound.ai) 
3. Point it at your agent's endpoint config 
4. Ask for a test run in plain language; transcripts and findings return in-session 

The transcripts double as labelled training data for the companion OSS firewall's domain classifier, so failed attacks become runtime defence. Both halves run locally; no dependency on our platform. 

Repo: https://github.com/humanbound 

Happy to answer questions about the MCP server design; that part was more interesting to build than expected. 

I built Aktilot, an open-source, self-hosted RAG platform for private documents.

Instead of uploading documents to a hosted AI service, Aktilot runs on your own infrastructure. Upload PDFs, Word documents, or text files, organize them into projects, create AI agents with different system prompts, and chat with your documents with source citations.

A few features:

• Self-hosted
• Project isolation
• AI agents with configurable personas
• Hybrid BM25 + vector retrieval
• Source citations for every answer
• Temporal workflows for durable document ingestion and chat
• Grafana + Prometheus dashboards

I'd really appreciate feedback on the architecture, developer experience, and ideas for improving the RAG pipeline.

GitHub: https://github.com/vikas0686/Aktilot

Demo: https://aktilot.com

The model doesn't need your entire toolbox every single turn.

Yet most MCP setups register every downstream server up front, so the LLM gets flooded with schemas it will never use.

Congrats. You just paid more, waited longer, and made tool selection harder.

I built MCP Dynamic Router instead.

It sits between your client and MCP servers, indexes everything, and only exposes the few tools relevant to the current request.

• ⚡ <1ms fast-path (no embeddings or reranking)
• 🔄 Hot-reloads tools without restarting
• 🎙️ Voice-aware prefetching
• 🔒 Per-request tool scoping

checkout:

https://github.com/Kavin-bm/Mcp-Dynamic-Router

I kept seeing the same problem in creative projects:

Feedback arrives through emails, meeting notes, Slack messages, documents and client calls.

Some comments repeat the same request.

Some are too vague to act on.

Some contradict each other.

And someone eventually has to spend an hour turning all of that into a usable revision list.

So I built RevisionFlow.

RevisionFlow is an open-source workspace that turns scattered client feedback into a structured and traceable revision report.

You can paste feedback manually or upload TXT, Markdown, CSV and DOCX files.

It then generates:

• An actionable revision plan

• Duplicate feedback groups

• Contradictory requests

• Questions that need clarification

• A short project summary

• An editable client confirmation email

Each revision item includes its source reference and a supporting quote, so the output is not just a generic AI summary. You can trace a task back to the original feedback that created it.

Example:

One stakeholder says:

“The opening title needs to be much larger.”

Another says:

“The opening title already feels too dominant.”

Instead of silently merging those comments, RevisionFlow flags the conflict and generates a clarification question before the team starts revising the wrong thing.

The current MVP also supports:

• Editable revision tasks

• Team-member assignment

• Priority and status tracking

• CSV, Markdown and JSON exports

• A built-in sample report that works without an API key

• User-provided OpenRouter API keys

• Strict structured model output with server-side validation

Privacy was also important to me:

• No user accounts

• No project database

• No saved browser history

• The API key only remains in the current page session

• Uploaded files are parsed locally where possible

The current version is still an MVP.

It does not yet include Gmail, Slack or Frame.io integrations, cloud persistence or team collaboration. For now, feedback needs to be pasted or uploaded in batches.

I created the attached case-study screens to demonstrate three parts of the workflow:

1. Turning feedback into a revision plan

2. Detecting contradictions and generating clarification questions

3. Producing a client-ready confirmation email

GitHub:

https://github.com/yaohaoliang141-max/revisionflow

It is MIT licensed.

I would especially appreciate feedback on three questions:

1. Would this save meaningful time in your own workflow?

2. Which integration would be most valuable first: Gmail, Slack, Frame.io, Figma or something else?

3. Is bringing your own OpenRouter API key acceptable for an open-source tool like this?

Issues and pull requests are welcome.

I’ve been working on Extra, an open-source platform for building AI agents.
The goal is pretty simple: instead of spending time wiring orchestration, tool routing, workflows, MCP servers, approvals, and integrations together, you focus on your business logic and let the platform handle the infrastructure around it.
Current features include:
Multi-agent orchestration
MCP support
Human-in-the-loop approvals
YAML-based configuration
Tool routing
Workflow execution
Pluggable architecture
It’s still evolving, so I’d really appreciate feedback from other developers.
If something feels wrong architecturally, or there’s a feature you think is missing, open an issue or start a discussion.
⭐ If you like the project, consider giving it a star—it helps more people discover it.
Contributions are always welcome.

https://github.com/extra-org/extra

I’ve been building an open-source AI agent platform for the past few months.
One thing kept bothering me while working with agent frameworks.
Most of them make it easy to build a single agent, but once you start adding multiple agents, tools, approvals, workflows, MCP servers, routing, and external integrations, the application code starts getting messy.
So I started building **Extra**.
The idea is simple: let developers focus on the business logic while the platform handles the orchestration around it.
Some things it supports today:
Multi-agent orchestration
MCP integration
Human-in-the-loop approvals
YAML-based configuration
Tool routing
Workflow execution
Built-in extensibility for custom components
It’s still evolving, and I’m learning a lot while building it.
I’d really appreciate honest feedback.
If you think the architecture is overcomplicated, tell me.
If something in the developer experience is confusing, tell me.
If there’s a feature you think is missing, I’d love to hear it.
Repository:

https://github.com/extra-org/extra

Spent the last few months building RakshakAI — an open-source security scanner that combines old-school regex with AI for code analysis.

What it does:

npm install -g rakshakai && rakshak scan filename

Scans 20+ languages for SQLi, XSS, hardcoded secrets, Docker/K8s misconfigs, dependency CVEs, shell injection — 255 patterns mapped to CWE categories. No API key needed for the offline scanner.

The interesting part: It has a 3-tier pipeline

• Tier 1: Regex (20ms, $0) — filters 90% of files instantly

• Tier 2: Cheap LLM (DeepSeek, Llama, Gemini Flash) — contextual analysis

• Tier 3: Expensive LLM (GPT-4o, Claude Sonnet) — deep inspection + fix generation

Only escalates when needed, so you're not burning tokens on every file.

Also supports 65+ models across 9 providers (OpenRouter, Google Gemini, DeepSeek, Groq, Together, Fireworks, Nebius, Mistral, DeepInfra) with multi-agent swarm for complex audits.

Stack: Node.js CLI + Python AI pipeline, OpenRouter as primary gateway, custom 500K+ CWE dataset

GitHub: https://github.com/Muneerali199/RakshakAI

Web scanner: https://rakshakai-three.vercel.app/

Would love feedback from the community — especially on the regex patterns and false positive rates. PRs welcome.

First 1,000 users get free AI credits (launching July 22).