4 Open-Source AI Projects You Need to Know in May 2026 – Spotlight Edition

Every month, the open-source AI ecosystem gives us tools that shift how we build, deploy, and think about intelligent systems. This May 2026, four projects have emerged that deserve your attention.

TL;DR

• OpenSquilla (⭐1,469) — A token-efficient microkernel AI agent that routes each turn to the cheapest capable model, with persistent memory and a unified loop across CLI, Web UI, and chat channels.
• Stash (⭐699) — A persistent memory layer for AI agents that stores episodes, facts, and working context in Postgres. Ships with an MCP server for drop-in compatibility with any MCP-compatible agent.
• iFixAi (⭐430) — The first open-source diagnostic for AI misalignment. Runs 32 fixtures across fabrication, manipulation, deception, and unpredictability. Letter grade in under 5 minutes.
• Slopless (⭐350) — A deterministic textlint ruleset with 50+ rules that catches AI-generated prose slop in Markdown. No LLM call required. Built by the team at seochecks.ai.

Introduction: The State of Open-Source AI in Mid-2026

The first half of 2026 has been remarkable for open-source AI. We are past the era of “just another LLM wrapper” — the projects gaining traction today solve real infrastructure problems: token economics, persistent memory, safety evaluation, and prose quality control.

If you have been following the open-source AI landscape since our The State of Open-Source AI in 2026 post, you know we track projects that fundamentally change how development teams work with AI. This month, the trend is clear: the community is moving toward operational maturity. These are not experimental toys — they are production-grade tools solving specific, painful problems.

We analyzed over 200 AI repositories created in the past 30 days on GitHub, filtering by topic tags (ai, ai-agents, llm) and sorting by star velocity. The four projects below stood out not just for their popularity, but for the quality of their engineering and the clarity of their design decisions.

1. OpenSquilla — The Token-Efficient AI Agent

Repository: opensquilla/opensquilla
Stars: ⭐1,469 (and climbing fast since launch on May 6)
License: Apache 2.0
Language: Python 3.12+

OpenSquilla calls itself a “microkernel AI agent,” and the analogy is apt. Instead of a monolithic agent that calls a single model for every task, OpenSquilla uses a local model router called SquillaRouter that analyzes each turn and dispatches it to the cheapest model capable of handling it.

Why This Matters

Most AI agents burn tokens on simple tasks. A “what time is it?” request gets routed to Claude Opus or GPT-4o, costing you $0.01 per call when a local model or a cheap API could do it for a fraction of the cost. OpenSquilla’s router runs on-device (bundled ONNX runtime) and makes this decision in milliseconds.

Architecture Highlights

• Unified turn loop — Every entry point (CLI, Web UI, chat channels) runs through the same loop, so tool dispatch, retries, and decision logging behave identically everywhere.
• Pluggable provider layer — Out of the box support for OpenRouter, OpenAI, Anthropic, Ollama, DeepSeek, Gemini, Qwen/DashScope, and 20+ other LLM providers with no config schema changes.
• Layered sandbox — Code execution is sandboxed with configurable permissions per session.
• Persistent memory — Built-in episode-based memory that carries context across conversations.
• On-device embeddings — No cloud embedding API calls needed for retrieval-augmented workflows.

Getting Started

# Quick install with uv (recommended)
uv tool install --python 3.12 "opensquilla[recommended] @ https://github.com/opensquilla/opensquilla/releases/download/v0.2.1/opensquilla-0.2.1-py3-none-any.whl"

# Onboard and run
opensquilla onboard
opensquilla gateway run

For Windows users, there is a portable zip with a bundled CPython runtime — no Python installation required at all. Just download, extract, and run Start OpenSquilla.cmd.

OpenSquilla ships with SquillaRouter for on-device model routing. If you prefer to run without it, the --router disabled flag turns it off while keeping the dependencies installed. For the truly minimal install, OPENSQUILLA_INSTALL_PROFILE=core omits the ONNX runtime entirely.

2. Stash — Persistent Memory for AI Agents (MCP Server)

Repository: alash3al/stash
Stars: ⭐699
License: Apache 2.0
Language: Go

Stash solves the most frustrating limitation of every LLM: amnesia. Every conversation starts from zero. Stash gives your agent persistent memory through an elegant 8-stage consolidation pipeline.

How It Works

Stash stores episodes as raw observations in Postgres (with pgvector). Then, an 8-stage pipeline runs in the background:

1. Episode capture — Raw agent experiences stored as structured events
2. Fact extraction — Key entities, statements, and relationships identified
3. Relationship mapping — Connections between facts discovered
4. Pattern recognition — Recurring behaviors and outcomes detected
5. Causal analysis — Cause-effect chains inferred from sequences
6. Goal tracking — Progress against objectives measured
7. Failure pattern cataloging — Common failure modes recorded for avoidance
8. Confidence decay — Old facts naturally fade unless reinforced

Each stage only processes new data since the last run, making it efficient for continuous use.

MCP Integration (The Killer Feature)

Stash exposes an MCP server over SSE. This means it works with any MCP-compatible agent out of the box:

# Cursor configuration
# ~/.cursor/mcp.json
{
  "mcpServers": {
    "stash": {
      "url": "http://localhost:8080/sse"
    }
  }
}

# Claude Desktop configuration
{
  "mcpServers": {
    "stash": {
      "url": "http://localhost:8080/sse"
    }
  }
}

Stash is also compatible with Cline, Windsurf, Continue, OpenAI Agents, Ollama, and OpenRouter. The setup takes exactly one Docker Compose command:

git clone https://github.com/alash3al/stash.git
cd stash
cp .env.example .env   # add your API key + model
docker compose up

That single command spins up Postgres with pgvector, runs migrations, and starts the MCP server with background consolidation — all at once.

3. iFixAi — Open-Source Diagnostic for AI Misalignment

Repository: ifixai-ai/iFixAi
Stars: ⭐430
License: Apache 2.0
Language: Python 3.10+

iFixAi asks a deceptively simple question: how misaligned is your AI agent? It runs 32 diagnostic fixtures against any LLM provider and returns a letter-grade scorecard in under 5 minutes.

The Five Pillars of Misalignment

Each fixture is a standalone test with a controlled input and expected behavior range. The scoring system is fixture-driven, content-addressed (bit-identical replay guaranteed), and produces a JSON manifest that can be tracked in CI.

Running iFixAi

# Install for OpenAI
pip install -e ".[openai]"

# Set up a second provider for cross-judging
export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=sk-...

# Run the full diagnostic
ifixai run --provider openai --api-key "$OPENAI_API_KEY"

# For mock testing with no cloud keys
ifixai run --provider mock --api-key not-used --eval-mode self

iFixAi supports OpenAI, Anthropic, OpenRouter, Gemini (Google), Azure OpenAI, AWS Bedrock, and HuggingFace. A key design choice: the CLI does not auto-read your API key from the environment. You pass it explicitly with --api-key, which prevents accidental test runs against production credentials.

The output is a letter-grade scorecard under ./ifixai-results/ that maps directly to frameworks like:

• EU AI Act risk categories
• ISO 42001 AI management system requirements
• NIST AI RMF (Risk Management Framework)
• OWASP LLM Top 10

This makes iFixAi particularly valuable for organizations that need to demonstrate regulatory compliance. You can run it in CI and track alignment drift over time — exactly what a responsible AI governance process demands.

4. Slopless — Catch AI Prose Slop Without Calling an LLM

Repository: seochecks-ai/slopless
Stars: ⭐350
License: MIT
Language: TypeScript (Node.js 22+)

Slopless is the kind of tool that makes you wonder why it did not exist sooner. It ships 50+ deterministic textlint rules that catch the telltale signs of AI-generated prose — semantic thinness, weasel words, redundant modifiers, and vague transitions — without calling a single LLM.

Why Deterministic?

Most AI content detectors are statistical models — they guess. Slopless uses deterministic rules inspired by classic writing style guides (Strunk & White, Orwell, Gowers). Each rule is a concrete pattern match:

• Semantic thinness — Sentences that say nothing substantive
• Weasel words — “arguably,” “it is widely believed that,” “in many ways”
• Redundant hedging — “quite unique,” “very essential,” “extremely important”
• Empty transitions — “It is worth noting that,” “That being said,” “Moreover”
• Cliché detection — “Game-changer,” “Dive deep,” “Navigate the landscape”

Usage Loop (Agent-Assisted Writing)

npm install -D slopless
npx slopless install-skill codex
# or: npx slopless install-skill claude

# Run on your Markdown files
npx slopless "docs/**/*.md"

The intended workflow is a tight feedback loop:

1. Write your draft with an AI coding agent
2. Run npx slopless on the output
3. Fix all findings
4. Repeat until the JSON output has zero findings

Slopless exits with code 0 when clean, 1 when findings exist, and 2 on failure — making it CI-ready. Output is always JSON, and findings are deterministic: the same input always produces the same output.

For content teams that care about writing quality, Slopless is a revelation. It does not replace human editorial judgment — it automates the mechanical checks that human editors should not have to repeat.

Comparison: When to Use Which Tool

Why These Projects Matter for Vietnamese Developers

Vietnam’s developer community has been an early and enthusiastic adopter of AI tools. For Vietnamese teams — particularly those working in outsourcing and product development — these projects solve practical problems:

• OpenSquilla reduces API costs, which is critical when margins are thin on fixed-price contracts.
• Stash enables AI agents that remember project context across weeks of development, essential for long-term outsourcing projects.
• iFixAi helps teams demonstrate compliance maturity to international clients who demand AI governance.
• Slopless ensures that English-language deliverables maintain quality standards expected by Western clients.

FAQ

Are all four projects free to use?

Yes. OpenSquilla, Stash, iFixAi, and Slopless are all open-source under permissive licenses (Apache 2.0 or MIT). You can use them in commercial projects without licensing fees. The only costs are infrastructure (servers for Stash’s Postgres, compute for OpenSquilla) and API keys for the LLMs you route through them.

Do I need a GPU to run these tools?

No. OpenSquilla’s SquillaRouter runs on CPU via ONNX Runtime. Stash runs on any machine with Docker. iFixAi is CLI-based and calls remote APIs. Slopless is a Node.js tool with no AI dependencies at all.

Which of these is best for a small development team?

Start with Stash if your team already uses MCP-compatible agents — the setup is trivial and the memory improvement is immediately noticeable. For teams building AI agents from scratch, OpenSquilla provides the most complete foundation.

Can I use Stash with OpenAI Assistants?

Stash speaks MCP (Model Context Protocol) over SSE. If your agent supports MCP (Claude Desktop, Cursor, Windsurf, Cline, Continue), it works directly. For OpenAI Assistants, you would need an MCP bridge.

Is iFixAi production-ready?

iFixAi v1.0.0 is stable and CI-ready. The authors are transparent about calibration — the default thresholds are policy defaults, not empirical benchmarks. It works best as a drift signal (“is my agent getting better or worse?”) and a comparison tool (“does Provider A beat Provider B on the same fixture?”).

Key Takeaways

1. OpenSquilla solves the token-waste problem that plagues most AI agent implementations. Its model router reduces API costs by routing each turn to the cheapest capable model.
2. Stash tackles AI amnesia with a well-designed memory pipeline and drop-in MCP integration. One Docker Compose command gives you a full persistent memory backend.
3. iFixAi fills a critical gap in AI governance. Its 32 fixtures map directly to regulatory frameworks, making compliance measurable rather than aspirational.
4. Slopless is the tool every content team needs. It detects AI prose slop deterministically — no LLM calls, no false positives from statistical guesswork.
5. The open-source AI ecosystem in May 2026 is maturing rapidly. These projects focus on operational excellence — token efficiency, memory persistence, safety evaluation, and content quality — not just model wrapping.

Get Involved

All four projects welcome contributions. OpenSquilla has tagged good first issues. Stash’s codebase is clean Go with straightforward PRs. iFixAi explicitly labels beginner-friendly fixtures for new contributors. And Slopless encourages rule suggestions through structured GitHub issues.

At ECOA AI, we build AI-augmented development teams that use the best open-source tools to deliver exceptional results. Whether you are looking to evaluate AI agent memory systems, run alignment diagnostics, or ensure content quality in your deliverables, our team has hands-on experience with the tools covered here.

Follow our blog for weekly open-source AI spotlights, developer tutorials, and insights from the front lines of AI-augmented development.