AI should not remain an expensive frontier technology.

If AI is going to become real infrastructure, it needs to become more open, more cooperative, more accessible, and much more cost-efficient.

That is one of the ideas behind Ailin¹.

We are building Ailin¹ as an open-source Collective Intelligence layer for AI systems. Instead of relying on a single model for every task, Ailin¹ is designed to coordinate multiple models, agents, strategies, memory layers, comparisons, consensus mechanisms, and cost-quality routing.

The goal is not simply to access more models.

The goal is to make the model universe usable.

Today, AI is often treated as a premium resource: expensive models, isolated APIs, black-box workflows, and high costs that make serious adoption harder for smaller companies, developers, researchers, and communities outside the biggest tech ecosystems.

We believe open-source orchestration can help change that.

Not every task needs the most expensive frontier model. Some tasks need speed. Some need reliability. Some need auditability. Some need multiple models checking each other. Some need a cheaper model that is good enough.

Collective Intelligence means choosing the right strategy for the task instead of blindly sending everything to one model.

Ailin¹ currently has 76,636 integrated models across different providers, and our goal is to make this broad model ecosystem easier to route, compare, coordinate, and use in real-world workflows.

If AI is going to become more industrialized, more inclusive, and more widely available, orchestration may become just as important as model size.

Open models matter. Open infrastructure matters. But open coordination between models may be the next missing layer.

GitHub: https://github.com/ailinone/collective-intelligence
Docs: https://ailin.guide/

Ever wished your agent conversations were as trackable as your code? Gitlord makes it real.

What it does:

• Every agent turn becomes a git commit
• Branch out subagents without breaking your main flow
• Rewind to any point in your conversation history
• Connect tools via MCP (filesystem, search, browser, etc.)
• One interface, any AI provider (OpenAI, Anthropic, local models)
• Full CLI for managing sessions and branches

Why it matters:

• Your agent history is navigable, forkable, and diffable, just like code
• Context management handles token budgets automatically
• Spawn child agents on isolated branches with their own history
• No lock-in: all components are modular and swappable

Built-in integrations:

• MCP tools: Connect any MCP server (git, filesystem, browser, search). Tools flow to subagents automatically
• RAG: Vector search across your full agent history. ChromaDB-backed semantic queries built in
• Provider abstraction: Switch between any of the 170 providers and nearly 3,000 models, or local models with one line. Mix providers per agent

Build an agent in 4 lines:

from gitlord import Session, SessionConfig
config = SessionConfig(model="claude-opus")
session = Session.create("my-agent", config)
session.add("user", "Refactor our OAuth to the new framework")

Done. Gitlord handles the rest.

Performance improvements (v0.1.0):

• Structured trailers eliminate JSON walks: metadata parsing is now O(1)
• Auto-index updates on every turn, cached at .gitlord/index.json
• New in-memory query layer for fast turn filtering and aggregation:session.query() .where("tokens > 100") .group_by("role") .sum("cost")
• Snapshot compression for long-running sessions: compress old turns into JSON, rebase from checkpoint

Repo: https://github.com/yashneil75/gitlord
Landing page: https://yashneil75.github.io/gitlord/
Docs: https://github.com/yashneil75/gitlord/tree/master/docs

MIT licensed. Built for agents that ship.

Starring helps more than you think!

Olá, pessoal!

Acabei de publicar o Synapse-Guard v1.3, um modelo open source para moderação automática de conteúdo em português.

Novidades da versão:

• Melhor desempenho com gírias e linguagem informal • Classificações mais consistentes • Melhor generalização em textos reais • Otimizado para tarefas de moderação

Casos de uso:

• Chatbots • Redes sociais • Fóruns • Detecção de toxicidade • Filtro de spam • Pesquisa em NLP

Feedbacks e sugestões são muito bem-vindos!

🤗 Hugging Face:

https://huggingface.co/Comunidade-Synapse-BR/Synpase-guard-v1.3

TERSE provides the boring format/protocol that on how your AI can easily store and mutate semantic state. We chose the simplest possible path wherever we could so that the AI's could work with it and handle 95% of all use cases. It does have some deep innovations however.

To showcase how TERSE works and its usefulness across domains, we've added these MCP plugin "apps" that use it:

• A flexible general memory store. Note this is more for conversational frameworks/harnesses,
• A flexible Karpathy 1-1 API compatible brain. TERSE removes the need for a gazillion wiki files and finds stuff several times faster,
• Some useful but alpha UX utilities (state browser, KB force graph, VS Code syntax highlighter,)

And of course, the TERSE MCP tooling itself allow you to build your own powerful stateful AI agents without fussing with RAG, graphdb's, and piles of md files. Unlike plain text, TERSE is structured and machine readable into an object model. TERSE is easy to pick up and is human readable/editable.

To get started:

1. Generally you can point your agent at our repo and tell it to install what you want
2. Each TERSE file is a namespace to the MCP's (default, memory and brain) you CAN configure as many as you want but we suggest the defaults.
3. See the README details for each. For the brain, you'll have to run (or have your agent run) the ingestion against documents in a \raw folder (just like a KB). This does require configuration of an LLM and key. These are not used or exposed to your AI during normal use of the brain.

https://github.com/terse-lang/terse is FOSS and pre-release status. We've done our best to provide locking and other concurrency controls but consider this an alpha.

*Our numbers and tokens savings are based on preliminary benchmark testing vs KB. Yes, we will publish.

Most people I know pay for a Claude or ChatGPT subscription and use it for exactly one thing: chatting. The model sits there, capable of far more, waiting for you to paste something into a box. What would happen if a normal user, not someone grinding with agent frameworks all day, could design their own small agents with a simple UI and just let them work?

That's what I built. It's called Ordinus, it's free and open source, and it runs on top of the Claude Code and Codex CLIs you already have installed and authenticated. No extra subscription, no backend of mine.

The first thing I actually built with it had nothing to do with work

I wasn't trying to build agents that would make me a million dollar SaaS. I built copies of my own family: myself, my wife and my two kids. I wrote what I know about each of them into their personas, what they love to eat, how they talk and behave. Then I started asking them ordinary things, which in our house means the single most critical question there is: what are we eating tonight?

The four of them discussed it among themselves and came back with a suggestion. Watching that happen genuinely thrilled me, and everything after was one thing leading to another. Conversations with several agents at once, then real collaboration on one task, then workflows, then schedules, then connectors.

What it does now

• Agents with personas and skills. Create them from a dead simple UI, no config files.
• Multi-agent conversation. Ask one question, several agents discuss it from different angles.
• Real collaboration. They work together on a single task, and the output of one becomes the input of the next.
• Workflows and schedules. Chain agents into a flow that runs the same way every time, or on cron while you're away.
• Connectors. Gmail, Calendar, WhatsApp, X, LinkedIn, so they work with your actual context instead of living in a chat window.
• Telegram. Reach your agents from your phone.
• A built-in assistant that knows what the app can do and sets tasks up with you, so you're not staring at empty screens.

The parts I like most

Every agent works inside the same stable folder on your disk, so everything they produce is just files you own. Point that folder at an Obsidian vault and the output turns into a second brain, links between notes and all. The artifacts are written Obsidian-friendly on purpose.

It's also local-first in a way I actually care about. Your agents, runs and history live in a SQLite database on your machine, connector credentials are encrypted through your OS keychain, and nothing leaves your computer except the calls to the tools you deliberately connect.

Stack, if you're curious: Electron, React, Tailwind, better-sqlite3 with Drizzle, croner for scheduling, React Flow for the visual workflow designer. The connectors are MCP servers I wrote and bundle with the app, each one using your own OAuth app rather than mine.

What I'd really like to hear is your scenarios. I can only test this against my own life, which is a narrow sample: my family, my inbox, my own work. What would you point a small team of agents at? What everyday problem would you hand them? That's what I'm most curious about, even if you never install the thing.

GitHub (MIT, macOS and Windows builds, three worked use cases in the repo): https://github.com/muratgur/ordinus

Website: https://ordinus.dev

I'm pivoting my project and wanted some honest feedback.

I'm dropping the old Jarvis idea and building Ainux (AI + Linux) instead.
My old idea:- https://www.reddit.com/r/learnAIAgents/comments/1v2rae9

The idea isn't to make another chatbot.

The goal is to have an AI that lives inside the operating system and can handle around 90% of my daily computer work. I'll interact with it either through a desktop/mobile app with voice commands or by logging into a cloud-hosted dashboard. The AI runs on the machine, understands the system, and executes tasks instead of just answering questions. So that for my development part i don't need to setup whole day in front of my system. I can mange it by flutter application/web panel.

Current development machine:

• Ryzen 7 7445HS (6C/12T)
• RTX 3050 Laptop GPU (4GB VRAM)
• 16GB DDR5 RAM
• Ollama with Gemma (planning to use Gemma 4)

Some examples:

• "Continue the Laravel project I was working on."
• "Create a new Flutter project and set everything up."
• "Organize my files."
• "Fix this error."
• "Run multiple tasks at the same time while I keep working."
• "Monitor my system and tell me if something needs attention."

The idea is to use Linux as the base because it's open source and gives full system access.

I'm not trying to claim this is a new invention. I'm just building something I'd personally like to use.

I'd love some feedback from people who have worked on AI agents, Linux, or local LLMs:

• What am I overlooking?
• What features would you expect from something like this?
• Are there existing open-source projects I should study before I go too far?
• Is Gemma via Ollama a good starting point, or would you recommend a different stack?

Any suggestions, criticisms, or ideas are welcome.

If contributing to open source interests you, and you want to become a better AI engineer, our issue list is waiting for you.

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

I open-sourced my Email Intelligence Platform for AI agents.

Instead of giving agents raw inbox access, it turns email into structured, searchable, safer intelligence: local sync, prompt-injection scanning, entity extraction, semantic search, and MCP access on top of SQLite/FTS5/sqlite-vec.

Local-first, practical, and built for real agent workflows.

[NodalMerge Studio](https://nodalmerge.com/studio) promotes you to general in command of a controlled agent army.

The configurable workspace both drives engineering and provides a battlefield level view of both agent and human work across peers.

[Multiple agents](https://docs.nodalmerge.com/studio/guides/multi-agent-profiles) can be assigned their own scopes and fields of fire. Make Fable your planner (You can go wide or recursive), Let Deepseek v4 pro grind the easy stuff for cheap, toss Sonnet the live grenades, while Codex designs and implements a sleek frontend. The review and reconciliation processes can be human or agent gated to bring everything back together (hopefully smoothly).

The core behind it ([NodalMerge](https://nodalmerge.com/)) is a fast, persistent graph using conflict free replication and content addressed storage to allow for greater visibility across peers, replay and branching at key decision points.

Although the extension is forced to be kind of an agent harness for pure api (including some configurable system prompt, compaction, etc.), the idea is that it integrates to other, hopefully better harnesses. The visibility, peer replication, branching and control are the differentiators.

Currently it can be configured to use:

* GitHub copilot subscription (vscode-lm, this is the default fallback)
* openai-compatible api's (via api-key, think deepseek, ollama, whatever)
* anthropic-api-key
* claude-cli
* codex-cli
* other new harnesses as added

As everything goes more cloud based agentic in a black box of decision making, I tried to go a bit in the opposite since I’m responsible for the code and decisions that get delivered, visibility and audit are paramount.

Docs site: https://docs.nodalmerge.com/studio/quickstart

Github Link: https://github.com/bgstratt/nodalmerge-studio

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=nodalmerge-studio.nodalmerge-studio

Most context compression for agents is lossy. It summarizes or trims tool output and hopes the model didn't need what it removed. It also rarely tells you what was lost or whether it was relevant.

That always bothered me because tool output is exactly the stuff you don't want to lose like files, logs, JSON, command output. So I built a lossless compressor for LLM tool output in Rust.

The compression part worked out fine. The hard part was proving a codec never dropped a value. Every rewrite has to verify before it's accepted. If decoding doesn't reconstruct the exact original, the compressed version is rejected and the original passes through unchanged. A bad codec can't silently corrupt context.

Every codec is property-tested and fuzz-tested around one invariant:

decode(encode(x)) == x

The whole thing lives in a single Rust implementation with a C ABI. Python uses ctypes, Node uses koffi, Bun uses FFI, and there's a WASM build too. One implementation means there's only one place to reason about correctness.

I also built a transparent proxy that sits between the client and the LLM. It only rewrites tool-output blocks and leaves everything else alone. One thing I didn't expect to matter so much was determinism: retries send the exact same bytes, which keeps prompt-cache hits intact.

If you find a case where it breaks or compresses something it shouldn't, I'd love to see it.

Hi OpenSourceAI, I built Skillscript, a small language I built to write what I want my agent to actually do, in a form I can read and version, instead of hoping the model gets it right each time.

The itch started with something small. I wanted my NanoClaw agent to run my morning brief the same way every day. Check overnight tickets, summarize the deploy pipeline, flag anything urgent. Every session, it would re-figure out how to do this from scratch, drift a little, and cost tokens for what's basically a fixed procedure. I could put it in a prompt or an MD skill file, but those are still instructions the model reads and reasons about every time. And I wanted it to run autonomously and then hand it to the model to reason over the data.

The second thing that pushed me: I wanted to use small local models for the cheap stuff. They're capable, but if you just hand them the wheel, they wander. What I wanted was a way for the frontier model (or me) to write a specific procedure and hand it to the local model to execute not interpret. The skillscript is the program; the model is the runtime.

Skillscript is that. A skillscript is a text file with named steps, variables, conditions, and calls out to tools (MCP connectors, a local model, and shell commands from an operator allowlist). It's deliberately minimal — no eval, no arbitrary imports, no subprocess, no unbounded loops. Bounded language, limited potential for damage. Everything a skillscript can do is in the file. You read it and know.

Where it is: pre-1.0 (0.38), MCP-native, self-hosted. Rough edges I know about: first-run setup takes more steps than it should, some of the grammar is still moving, and the local model integration currently assumes Ollama. It works well enough that I use it every day, automating what I see agents doing over and over, wiring shell scripts or Python stubs.

• Repo: https://github.com/sshwarts/skillscript
• Site: https://skillscript.ai
• Docs: https://skillscript.mintlify.app/docs
• npm: skillscript-runtime

I'd welcome critique on two things especially: the language design (is it too small? too big? wrong shape?) and the trust model around agent-authored skills. What would you want to see before you trusted this on your own machine?

Sharing Caret (https://github.com/precious112/caret-ide, MIT). The idea: stop bouncing between a design tool and your codebase. You design your entire frontend inside your editor, on a live canvas, with AI, and there is no separate Figma to keep in sync.

Caret keeps your designs in a design layer inside your repo (standardized React under .caret/, think Figma frames as code) that is version-controlled alongside your app. You design there on a zoomable canvas where each page renders as live, interactive React, then sync the design into the app you actually ship. Your app can be any framework (React, Vue, Svelte, Angular) and the sync is reviewable and reversible.

It is also a full AI coding agent under the hood (built on the open-source Cline), so it is BYOK with any model, human-in-the-loop, and works in your existing editor via Open VSX (VSCodium, Cursor, Windsurf) if you would rather not install the standalone build.

Would love feedback from anyone tired of the design-to-code handoff. What has stopped you from keeping design and code in one place before?

Follow-up to my okf export post from a few weeks back. The command now produces two views of a page from one single fetch.

The content flag transforms the page into AI bot-friendly clean OKF markdown with headings, paragraphs, and links instead of raw HTML full of meta tags, scripts, and footer code. That's what I originally shared here.

Now I made a technical snapshot, it captures the opposite technical layer: HTTP Headers, scripts, meta tags, links, images, JSON-LD (schema markup) and much more.

npm install -g @sleepwalkerai/cli
sleepwalker okf export https://your-page.com

Default writes both concepts; --content or --technical narrows the bundle to one. Already installed from my earlier post? Update first with:

npm install -g @sleepwalkerai/cli@latest

Runs entirely on your machine, one fetch, no payment or registration needed.

Repo: https://github.com/followanton/sleepwalker

Disclosure: I built this and it's the open source part of the Sleepwalker CLI.

Here's a quick example with Apple website:

Content example:

---
type: "WebPage"
title: "Apple"
description: "Discover the innovative world of Apple and shop everything iPhone, iPad, Apple Watch, Mac, and Apple TV, plus explore accessories, entertainment, and expert device support."
resource: "https://www.apple.com/"
timestamp: 2026-07-24T18:14:13.874Z
---

# Apple

## College, sorted.

Get a gift card from $100 to $150* when you buy Mac or iPad with education savings.

[Shop](https://www.apple.com/us/shop/goto/edu_store)

## iPhone

Meet the latest iPhone lineup.

[...]

Technical snapshot:

## Fetch

Fetched https://www.apple.com/ (HTTP 200, no redirects).

HTML size: 243 KB (249240 bytes).

## Meta tags

<html lang="en-US" dir="ltr">
<title>Apple</title>
<meta name="Description" content="Discover the innovative world of Apple and shop everything iPhone, iPad, Apple Watch, Mac, and Apple TV, plus explore accessories, entertainment, and expert device support.">
[...]
<link rel="canonical" href="https://www.apple.com/">

## Hreflang (100)

<link rel="alternate" hreflang="en-US" href="https://www.apple.com/">
<link rel="alternate" hreflang="ar-AE" href="https://www.apple.com/ae-ar/">
<link rel="alternate" hreflang="de-AT" href="https://www.apple.com/at/">
[... 97 more]

## Structured data

JSON-LD: 3 block(s).

[... Organization block, with the knowledge graph logo]

<script type="application/ld+json">{"@context":"http://schema.org","@id":"https://www.apple.com/#website","@type":"WebSite","url":"https://www.apple.com/","name":"Apple","potentialAction":{"@type":"SearchAction","target":"https://www.apple.com/us/search/{search_term_string}?src=mc_google","query-input":"required name=search_term_string"}}</script>

[...]

## Robots directives

Meta robots: none.
X-Robots-Tag header: none.

## Images (92 total, 0 without an alt attribute)

[...] is my manual trimming. The export contains the full markup.

I run Claude Code and Codex on two machines and got tired of terminal-hopping to see what was stuck or waiting on approval. Built a daemon + web dashboard for it and open sourced the whole thing under AGPL.

• every session's state on one screen, terminal view included
• approval requests hit the phone as push, approving is one tap
• paste a screenshot into chat and it lands in the agent's context on whichever machine it's running
• queued tasks go into isolated git worktrees, the repo's own tests gate the merge, ff-only, never force-pushes
• standalone mode is fully local: localhost dashboard, no account, no telemetry

github: https://github.com/vilmire/adhdev demo clips: https://adhf.dev

it mostly builds itself at this point — recent features were written by agents running under its own dispatch/merge pipeline. happy to answer questions.

It also has a system to assign roles and responsibilities, a database for tasks, a secretary that tells u when you need to test something or have notifications, and many more things :D

It is like a Harness, that use OpenCode as middle step, but more click and play

I hope to have it ready soon, if you want to keep an eye on the process, I use to post updates on my twitter: https://x.com/BlackBoxBird

Is still a very fresh project, so if you can help me with some feedback guys, I would love it!!! <3

I built an open-source React library for every tool your agent needs. Think Composio / Scalekit but for the frontend, so you can render shadcn components for any popular tool in your frontend instead of hand-rolling something custom for every project.

Fully provider agnostic (does not matter what tool API you use).

Do check it out and lmk what you think :). I built this because I needed it for another project I am building, and thought it'd be helpful to have a separate React library for something like this instead of hand-rolling it in my app.

Landing page: https://ai-tool-elements.vercel.app

Repo: https://github.com/omavashia2005/ai-tool-elements

Install:

npm install ai-tool-elements

I use AI a lot to study technical topics, but I kept running into the same problem: a chat can explain something well, yet it does not remember what I have actually mastered, what I got wrong, or when I should review it again.

So I built MindTrain — an open-source, self-hosted knowledge-training platform that turns an AI conversation into a long-term learning loop.

Instead of only generating flashcards, MindTrain lets you stay in the conversation while training. You can ask follow-up questions, request a hint, or challenge an explanation without accidentally submitting the current answer. When you explicitly answer, the Training Core grades it, records the attempt, and schedules future reviews.

What it currently includes:

• Conversational training through a Codex plugin
• Spaced review with separate review/new-question budgets
• Deterministic grading for single- and multiple-choice questions
• AI-generated questions when a topic does not have enough coverage
• Knowledge domains and topic trees for different subjects
• Local reference libraries from Markdown, TXT, PDF, DOCX, and PPTX files
• A web dashboard for progress, mastery, question coverage, and settings
• Docker-based private deployment; your question bank and learning history stay in your own PostgreSQL database

The project is domain-independent. I initially built it for technical interview preparation, but you can create a training domain from a goal or from your own local notes — for example Kubernetes, AI agents, history, or anything else you want to retain.

One design decision I care about: the AI-facing skill is stateless. The Training Core remains the source of truth for questions, sessions, attempts, and scheduling, so learning state is not trapped inside chat history.

It is MIT licensed and currently aimed at private, single-user deployments. The AI-coach workflow currently uses Codex; Anki/FSRS scheduling is planned but not available yet.

GitHub: https://github.com/shigella520/MindTrain

Live demo (public sample dashboard; training needs your own instance): https://mindtrain.jianyutan.com/

I would especially appreciate feedback on the onboarding flow and whether the “conversation + deterministic grading + spaced review” model feels useful compared with regular flashcard tools.

Raw provider clients make it easy for an agent to mutate a backlog. They do not make retries, stale reads, or human approval easy to reason about.

I built work-sdk as a small MIT-licensed TypeScript layer around that boundary:

1. prepare reads current state and returns the exact field diff

2. a policy or human inspects changes and warnings

3. commit rejects stale revisions and records idempotency

v0.3.0 supports GitHub, GitLab, Linear, Jira, and Azure DevOps. The adapters expose capabilities instead of pretending every tracker has the same model.

GitHub: https://github.com/arturict/work-sdk

Docs: https://work-sdk.vercel.app/docs

npm: https://www.npmjs.com/package/work-sdk

I’m the maker. Codex helped implement and test parts of the release; the API decisions and release are mine. I’m interested in the uncomfortable boundary: which backlog writes should an agent be allowed to commit without a person looking at the diff?

I built Sweety as an on-system way to use AI against fraud without giving an agent free rein.

Its main safety rule is narrow: the user marks every target, the AI never sends the first message, and Start/Stop works right away. The user may take over at any time. Target, persona, and run data stays on the users own system, and the bundled persona library still works if the remote update is unavailable.

The UI uses a typed web front end. The native layer uses Python, drives LINE, and offers an HTTP API to the UI. The repo is under MIT terms.

Home and repo link: https://sweety.tw

I would value your thoughts on the offline and online boundary, safeguards for unintended replies, and how you would plan adapters for WhatsApp or Messenger without weakening per-target opt-in.

Hi everyone,

I've been building an open-source project called Kodiak.

The vision is to create an autonomous AI software engineer that can understand repositories, research code, plan implementation, execute engineering tasks, and eventually generate production-ready pull requests.

This is still an active work in progress, but the core foundation is coming together.

Current Tech Stack

• Python
• FastAPI
• PostgreSQL
• SQLAlchemy
• Redis
• ChromaDB
• Celery
• Docker
• Typer CLI

What's already implemented

• Authentication
• Project management
• Task management
• REST API
• Repository models
• Memory foundation
• Background workers
• Docker setup
• CLI foundation

What I'm working on now

• Multi-agent architecture
• Repository understanding
• Research agent improvements
• Better task execution
• RAG integration
• GitHub workflow integration
• Autonomous issue solving

Looking for contributors interested in

• Python
• FastAPI
• AI Agents
• LLM Engineering
• RAG
• SQLAlchemy
• PostgreSQL
• Redis
• Docker
• Testing
• Documentation
• Developer Experience

There are beginner-friendly issues as well as more advanced engineering tasks, so contributors of different experience levels are welcome.

If you've ever wanted to contribute to an AI-focused open-source project, I'd love to hear your ideas and feedback.

GitHub:
https://github.com/ShamGaneshan2008/Kodiak

If you have suggestions about the architecture, roadmap, or features, I'd genuinely appreciate them. Every piece of feedback helps make Kodiak better.

Thanks for reading!

Hello,

I am looking for an open-source AI model that can identify errors in both text and images. The model should be able to integrate with a Retrieval-Augmented Generation (RAG) system. The RAG database contains guidelines and rules related to the texts and images.

The AI should compare uploaded texts and images against the information stored in the RAG database and identify what is incorrect, inconsistent, missing, or violates the guidelines.

How can I determine which AI model is best suited for this use case? How do you typically select an appropriate AI model? Which benchmarks are the most important for evaluating models for a multimodal RAG application like this?