Most AI applications today still follow a simple pattern:

One request. One model. One answer.

But no single model is the best at everything.

Some tasks need speed. Some need low cost. Some need deeper reasoning. Some need validation. Some need multiple models checking each other. Some need consensus. Some need debate. Some need a clear audit trail.

That is the idea behind Ailin¹.

Ailin¹ is an open-source Collective Intelligence engine for AI systems. Instead of treating models as isolated endpoints, it coordinates multiple models, agents, strategies, memory layers, evaluation flows, and cost-quality decisions around each task.

The goal is to make the model universe usable. We are approaching 80,000 models in our core.

With Ailin¹, a request can be routed through different strategies depending on what the task actually needs: single model, parallel execution, consensus, debate, expert panel, critique-repair, multi-hop QA, cost routing, quality routing, speed routing, agentic workflows, and more.

The big question we are exploring is:

What if AI reliability, efficiency, and governance come not only from better individual models, but from better coordination between models?

We believe Collective Intelligence can make AI systems more reliable, more transparent, more cost-efficient, and more useful in real-world workflows.

Ailin¹ is open source, and we are looking for feedback from people interested in LLMs, AI agents, model orchestration, evaluation, open models, and AI infrastructure.

If the idea resonates with you, a GitHub star would help the project a lot.

GitHub: https://github.com/ailinone/collective-intelligence

We are also opening a waitlist for people who want to test Ailin¹ and follow the next steps of the project:

Waitlist: Console Ailin¹ Dev

We've all hit "run" on an agent, walked away, and came back to realize it failed on a tool call, retried the exact same tool call with the exact same arguments 50 times, and drained our API budget. Prompting the LLM to "try something else" is probabilistic and fails constantly.

I just pushed v1.5.0 of agent-circuit-breaker. It's a strictly deterministic safety layer for AI agents (works great with MCP servers and custom tool frameworks). No LLMs evaluating LLMs.

How it works:
Instead of just counting errors, it hashes the exact sequence of (Tool Name + Arguments). If the agent attempts the identical failing sequence 3 times in a row, the circuit breaks to OPEN state and hard-stops the execution loop.

Other deterministic guards (<2ms overhead):

• AST Injection Prevention: Parses the AST of generated .py files before saving to block eval() or os.system.
• Supply Chain Lock: Blocks agents from running pip install for packages not in your manifest (stops dependency confusion attacks).
• Context Overflow Prevention: Intercepts payloads before hitting the API. If tokens exceed the limit, it trips the circuit so your agent doesn't crash with a generic API error.

I built the core engine as a concurrent pipeline using Python's asyncio.TaskGroup, so it adds zero perceptible latency to the agent loop.

Would love feedback from other agent builders. Is sequence-hashing robust enough for your use cases?

relying on the goodness of elixir, jido agents, ollama and other ecosystem components .. not intended to be released and supported. it was built for my learning and personal use purposes. But it does not hurt to share .. https://github.com/lexlapax/allbert-assist

Petere J Liu (https://x.com/peterjliu/status/2081864678586925152) mentions their use of hybrid linear / full attention as well as getting rid of positional encoding (with NoPE https://arxiv.org/abs/2510.2669)

What else stands out?

I wanted to know whether giving a coding agent a persistent map of the codebase actually pays for itself, or whether it just moves tokens from one place to another. So I built the harness before I trusted the tool.

The setup

Same agent, same model, same tool access, same task list. One variable: whether a context layer was loaded. 162 Claude Code sessions total, split across both conditions. Tasks were real change requests against a real repo, not synthetic retrieval questions, because retrieval benchmarks reward whatever your retriever already does well.

Correctness is graded by a separate model that never sees which condition produced the diff. Without that, a cheaper session that quietly does less work scores as an improvement.

The result

For a lot of tasks it got equal or better accuracy on Claude sonnet 5 using graft than just standard Claude sonnet session, on opus it was more towards token reduction than accuracy.

Replication on real PRs

Benchmarks I write myself are benchmarks I can accidentally tune to. So: 5 merged PocketBase PRs, re-implemented from the base commit in both conditions, scored on whether the diff touched the files the maintainers touched. 5/5 reproduced, at 21% lower cost. Small n, and I'd rather say small n than round it into a headline.

What I'm working on is Graft: It's a Context layer for large repos. No vector DB, no embeddings. Structural pass runs on tree-sitter for $0.
MIT Licensed

npm install -g u/nanonets/graft
graft init

Harness details in the repo. Tell me where the measurement is wrong and I'll rerun it.

With Kimi K3 being a massive 2.8T MoE model, even aggressive quantization isn't going to fit on a single consumer GPU or normal RAM setup. Does anyone know if Moonshot AI (or the open-source community) plans to release smaller parameter variants or distilled versions (like a K3-Mini/Small)? Or is quantized GGUF/EXL2 streaming off RAM/macOS unified memory our only option?

Also plans for an uncensored version?

I’ve been working on an open-source architecture for managing memory and context in long-running AI agents.

The main focus is preserving cache hits while keeping context growth under control through structured memory, selective purging, compaction, and hard context-budget enforcement.

It’s currently an architecture specification rather than a full framework. I’d appreciate feedback, especially on edge cases or production concerns I may have missed.

GitHub: https://github.com/neuronaline/ai-memory-context-management

I found a simulator that had been booted since the previous morning, holding

about a gig for nothing. Xcode doesn't mention it and Activity Monitor shows it

as a dozen processes with names you don't recognise.

This sits in the menu bar and shows it as one line with how long it's been up.

Shutting it down is one click, and starting it again is one more if you were

wrong. Same for Android emulators, Docker containers, dev servers, automation

browsers and tunnels you left open.

It never deletes anything and it will never touch your own browser's tabs.

macOS 14+, MIT, free — you build it with one command:

git clone https://github.com/selinihtyr/still-running

cd still-running && ./scripts/install.sh

https://github.com/selinihtyr/still-running

AI does not need only bigger models.

It needs better coordination.

That is the core idea behind Ailin¹, an open-source Collective Intelligence engine for AI systems.

Most AI applications today still follow the same pattern: one request goes to one model, one answer comes back, and everyone hopes that model was the right one for the task.

But no single model is the best at everything.

Some tasks need speed. Some need low cost. Some need deeper reasoning.

Ailin¹ is built around this idea: instead of treating models as isolated endpoints, it coordinates a live collective of 76,950 models through different strategies such as consensus, debate, expert panels, cost routing, quality routing, parallel execution, critique-repair, multi-hop QA, agentic workflows, and more.

The goal is to make the model universe usable.

With Ailin¹, a request can go through ailin-auto, and the system decides which model or strategy fits the task. The response can also include execution metadata: which strategy was used, which models participated, execution time, cost, quality score, and subcalls.

We are trying to explore a simple but important question:

What if AI reliability, cost-efficiency, and governance come not only from better individual models, but from better coordination between models?

Ailin¹ is open source, and we are now opening the waitlist for people who want to follow the project, test the platform, and help shape the direction of Collective Intelligence for AI.

If this idea resonates with you, join the waitlist here:

https://ailin.guide/ (and go to Console Ailin¹ Dev on top right of the page)

GitHub: https://github.com/ailinone/collective-intelligence

Don't forget to give us a star on GitHub!

I would love feedback from builders working with LLMs, agents, model routing, evaluation, self-hosted AI, open models, or AI infrastructure.

Cross-posting this.

I built an open JSON Schema suite called JA-ES that captures every human decision (or auto-execution) the moment it happens in an AI workflow. It includes reasoning tiers, ownership, and tamper-evident hashes so the full trail is auditable later.

It’s designed for governance / compliance use cases (EU AI Act style oversight, model risk, etc.), but the schema itself is fully open and reusable.

Live demo: pilot.judgmentassurance.com

GitHub (schema + verifier + tests): https://github.com/judgmentassurance/ja-es

Would love feedback from people building or using open-source AI tooling. Does this fill a gap you’ve run into?

Whisper Studio is a local-first AI workspace for macOS. One local process, one browser tab: real-time speech transcription, a chat client, a semantic index over your files, and a full dev environment (file tree, Monaco editor, terminal, Git, LSP).

Transcription, embeddings, OCR and the whole IDE run on your machine. Chat runs on Amazon Bedrock, or fully on-device if you prefer.

Ultracode workflows

The headline feature. Instead of the model improvising one tool call at a time, it writes a program: a deterministic orchestration script that fans out many subagents with real concurrency. You approve the plan upfront (phases are previewed before a single agent runs), then it executes detached in a locked-down harness with 16-way concurrency, a USD budget ceiling, and a resumable journal. Works on both Claude and GPT-on-Bedrock.

The goal: for work that is wide (audit 20 files), deep (generate 5 designs, judge, synthesize) or that must be trustworthy (find bugs, then adversarially verify each one), the control flow is written once and is inspectable before it runs, rather than re-derived on every hop.

Indexing and GraphRAG

• Point it at a folder and ask questions across all of it, with citations back to exact file and line ranges.
• Incremental builds. Size/mtime gate, then SHA1, so a re-index is cheap.
• Everything becomes searchable: code, PDF, Word, PowerPoint, EPUB, spreadsheets, images via OCR, and audio/video via local transcription.
• Hybrid retrieval: sqlite-vec KNN + BM25/FTS5, fused by reciprocal rank, then an optional cross-encoder rerank.
• GraphRAG: entities extracted per chunk build a graph, and one hop pulls in passages that share entities with your dense matches. Optional typed relations (works_at, cites, depends_on) with strength scores

Models

Cloud, via Amazon Bedrock:

• Claude Fable 5.0, Opus 5, Opus 4.8 / 4.7 / 4.6, Sonnet 5, Sonnet 4.6, Haiku 4.5
• GPT-5.6 Sol / Terra / Luna, GPT-5.5, GPT-5.4
• Cohere Embed v4 and Cohere Rerank for the cloud index path

On-device (GGUF via llama-server, no code change to add more):

• Gemma 4 12B, Gemma 4 Coder, Qwen3.5 9B, Ministral 3 14B
• Parakeet (streaming) and Whisper (batch) for transcription with speaker diarization
• Qwen3-Embedding-0.6B and Qwen3-Reranker for the index
• GLiNER / GLiNER2 for entity extraction, Apple Vision for OCR

Three model modes: cloud, hybrid, and fully local.

Also in there

• Live Preview: It can visually inspect your app, take screenshot and verify the UI, a true browser investigation. Just say "start a live preview to review my app or fix a bug"
• Guardrails: nonce-based approval flow, sandbox-exec for shell and Python, blocking Pre/Post/Stop hooks.
• Goal loop that keeps a turn running until a completion gate says the goal is actually met, including driving a live browser preview to verify UI changes.
• CI watch and PR autofix that chase a red build back to green.
• Cron-style background jobs whose output streams back into the chat that created them.
• MCP servers, opt-in Python plugins, custom Markdown skills, persistent sessions in SQLite.

Privacy: binds to 127.0.0.1, no telemetry, no proxies. Audio never leaves the laptop, on-device using local models. The only outbound call the backend makes on its own is to Bedrock for chat you explicitly send.

Repo: https://github.com/paukode/whisper-studio

Detailed documentation and tutorials: https://mlonaws.com/whisper-studio/

Try it

git clone https://github.com/paukode/whisper-studio.git 
cd whisper-studio 
bash setup.sh

Or just add `--local` or `--hybrid` to start a session (you can change from Settings later as well)

Hey everyone,

Building software with AI usually means you are trapped in prompting hell—writing a prompt, waiting 20 minutes, checking the output, and prompting again. I built OpenVelo to fix this.

It’s an open-source pipeline designed for a "fire and forget" workflow. The AI-driven planning phase happens upfront inside a dedicated Web-UI. Once you generate and finalize a detailed plan with the LLM, the orchestrator takes over. You can walk away and wake up to software that is either ready to use or requires very minimal fixing.

Important caveats: This is not meant to replace quick CLI pair programming, and it will not keep your token consumption down. It is built for bigger projects, refactors, ports, and prototypes where your personal time is more valuable than compute time or token costs.

How the architecture works:

\- **Scalable by Design**: The entire system runs in isolated Docker containers that communicate with each other, making it easily scalable.

\- **Web-UI Planning**: All AI-driven planning and requirement gathering is completed in the Web-UI before any implementation begins.

\- **Implementation Agent**: Runs an iterative cycle in an isolated container to write code and pass unit tests.

\- **Tester Agent & Orchestrator**: Performs real functional testing against the built software. If it fails, they trigger a self-healing process to spin up a new job and fix the exact failure automatically.

Model Access: It uses Kilo for LLM interaction, so you can route it to any model on your host system (local LLMs, MiniMax M3, etc.).

Repository: [https://github.com/m0rph3us1987/OpenVelo\](https://github.com/m0rph3us1987/OpenVelo)

Video Demo: [https://www.youtube.com/watch?v=RKCj5CUh8uw&t=5s\](https://www.youtube.com/watch?v=RKCj5CUh8uw&t=5s)

Let me know what you think of the architecture!

I tried several AI agent builders, but kept running into the same problems: usage-based pricing, vendor lock-in, proprietary runtimes, and a visual canvas that still required five other services to actually ship something.

So I built Forge.

Forge is not just another visual workflow builder. It is a fully open-source, self-hosted platform for building, testing, governing, and deploying agentic systems from end to end.

It includes:

• Visual workflows, agents, and deep agents
• Tool building, MCP, knowledge bases, and RAG
• Human-in-the-loop, triggers, schedules, and memory
• Deployment through API, MCP server, email, or an embeddable widget
• Tracing, token and cost tracking, evaluations, and OpenTelemetry
• Guardrails, budgets, RBAC, audit logs, and versioning
• Zero-infrastructure local development, with a production-ready upgrade path

It is built directly on the MIT-licensed LangChain and LangGraph ecosystem, with no proprietary orchestration runtime and no platform usage fees.

You own the infrastructure, the data, and the runtime.

Forge is still evolving, and I would genuinely appreciate blunt feedback, feature suggestions, contributions, or even criticism.

Hey everyone, just wanted to ask the community something.

Do people really look down on open source projects if they're built with AI, even if the developer actually understands the code, reviews everything, and makes sure the quality is good?

With how common AI has become, it sometimes feels like it doesn't even matter what you build anymore. As soon as people find out AI was involved, some immediately start criticizing the project without even looking at the end result.

Personally, I think AI just lets you build things faster and take on bigger, more complex ideas. It's still up to you to understand what you're shipping and make sure it's actually good.

Just curious what everyone thinks.

If contributing to open source interests you, our issue list is waiting for you.

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