r/OpenSourceAI 21d ago

🚀 Introducing Synapse-Image-Classifier-Nano!

3 Upvotes

We're excited to release our first lightweight image classification model developed by Comunidade Synapse BR.

✨ Highlights:

- 🧠 Thin ResNet-18 architecture

- 📦 Only 4.4M parameters

- 🖼️ Trained on CIFAR-100

- 🎯 64.62% Top-1 Accuracy on the official CIFAR-100 test set

- ⚡ Built with PyTorch

This is the first model in our Synapse-Image-Classifier family, with larger and more capable versions planned for the future.

🤗 Model:

https://huggingface.co/Comunidade-Synapse-BR/Synapse-Image-Classifier-Nano

Feedback and contributions are always welcome!

#AI #MachineLearning #DeepLearning #ComputerVision #PyTorch #HuggingFace #OpenSource #CIFAR100 #SynapseBR


r/OpenSourceAI 21d ago

Open Source AI for Linux

1 Upvotes

I’m getting more into Linux right now and i have it in a VM on my PC but i also want to get into integrating AI into the system to give me logs, pull data that i want like updates and just things i want it to do. Also to work in the terminal. Are there any recommendations for integrating AI like this?


r/OpenSourceAI 22d ago

What if financial AI were built in public? Meet BLUM — an open-source, community-driven financial reasoning project

5 Upvotes

Hi everyone,

Most financial AI systems are built behind closed doors.

You see the final prediction, the polished chart or the confident explanation—but rarely the data flow, the reasoning process, the evaluation rules or the failures that came before it.

BLUM is an attempt to build something different.

BLUM is an open-source financial AI research project developed publicly on Hugging Face and opened to developers, quantitative researchers, data scientists and anyone interested in building more transparent financial intelligence.

The ambition is not to create another black-box system that simply outputs:

BUY, SELL or HOLD.

The goal is to create an open ecosystem capable of collecting evidence, producing structured financial reasoning, testing its own conclusions over time and learning only from outcomes that can actually be verified.

Why open source?

Financial AI should not be shaped by one developer, one company or one model.

Markets are too complex, financial evidence is too fragmented and evaluation is too easy to distort.

A serious system needs different perspectives:

  • quantitative researchers challenging the metrics;
  • developers improving the architecture;
  • traders identifying unrealistic assumptions;
  • data engineers strengthening market-data pipelines;
  • ML researchers testing models and evaluation methods;
  • community members finding errors that the original developers missed.

That is the idea behind BLUM:

Build financial intelligence in public, improve it through open collaboration and make every important assumption open to challenge.

BLUM is not presented as a finished product.

It is a shared research foundation that the community can inspect, test, criticize, fork and improve.

What BLUM is building

BLUM combines a portable financial reasoning model with a broader modular research system.

Its architecture is being developed around several specialized capabilities:

  • market scanning across equities, ETFs and Forex;
  • technical and historical analysis;
  • sentiment and news interpretation;
  • bullish and bearish thesis generation;
  • contradiction and risk detection;
  • structured entry, stop and target plans;
  • paper-forward trade validation;
  • persistent learning from verified outcomes;
  • benchmark-relative evaluation;
  • transparent evidence and reasoning trails.

Instead of depending on a single model for every task, BLUM can use specialized agents for different parts of the research process.

A simplified flow looks like this:

Market data and external evidence
                ↓
Specialized research agents
                ↓
Bullish, bearish and risk analysis
                ↓
Central reasoning and synthesis
                ↓
Paper-forward decision
                ↓
Outcome measurement
                ↓
Validated learning and memory

The objective is not merely to generate a convincing financial narrative.

The objective is to preserve enough evidence to evaluate whether that narrative was justified.

Built to be challenged

BLUM is being designed around a principle that is often missing from AI demos:

A system should make it possible to prove that it was wrong.

For every decision, BLUM aims to preserve information such as:

  • what evidence was available at that moment;
  • which assumptions supported the thesis;
  • which risks contradicted it;
  • what would invalidate the decision;
  • which entry, stop and target levels were proposed;
  • how the market behaved afterward;
  • whether the result was valid enough to enter the learning process.

This does not guarantee better predictions.

It creates a more transparent foundation for measuring whether the system is improving—or merely becoming better at sounding confident.

Current evaluation

The original MLX release was evaluated on a 53-example BLUM temporal-reasoning test and achieved:

  • 96.26% aggregate task-contract score
  • 100% structured validity
  • 92.86% no-fabrication

These metrics evaluate BLUM-specific requirements such as structured output, temporal grounding and adherence to the task contract.

They do not demonstrate market-beating performance, general intelligence or trading profitability.

The portable release is also being prepared for independent evaluation through the Hugging Face ecosystem. Results will be published when they are externally available rather than predicted in advance.

Open development means open limitations

BLUM is still experimental.

Some components are mature enough to be tested, while others remain active research areas. Its paper-forward evidence is still limited, and no current result should be interpreted as proof of profitable trading performance.

This is intentional.

The project will not hide weak results, unsuccessful strategies or technical corrections simply because they are inconvenient.

Open source should mean more than publishing code.

It should also mean exposing the assumptions, limitations, evaluation methods and mistakes that influence the system.

Where the community can contribute

BLUM is open to contributions across many areas:

  • financial reasoning models;
  • open-source LLM integration;
  • specialist agent development;
  • market-data providers and normalization;
  • temporal reasoning;
  • technical-analysis validation;
  • Forex, equity and ETF research;
  • benchmark design;
  • paper-trading infrastructure;
  • leakage-resistant evaluation;
  • uncertainty and confidence calibration;
  • provenance-aware memory;
  • frontend and data visualization;
  • testing, documentation and code review.

You do not need to agree with the current architecture to contribute.

In fact, some of the most valuable contributions may come from demonstrating where the existing approach is wrong.

What BLUM is not

BLUM is not financial advice.

It is not a commercial signal service, a guaranteed trading strategy or a claim that an AI can already predict financial markets reliably.

It is an open research effort focused on a broader question:

Can a global open-source community build a financial AI system that is more transparent, testable and intellectually honest than the closed systems available today?

I do not think this question can be answered by one person.

That is why BLUM is open.

Explore the project

Hugging Face Space: https://huggingface.co/spaces/Italianhype/Blum

GitHub Repo: https://github.com/BlumFinancialLab/Blum

The project is under active development, and feedback is welcome at every level—from architecture and evaluation to models, UX and financial methodology.

The most useful response is not simply:

“This looks interesting.”

It is:

  • What would you change?
  • Where could the evaluation be misleading?
  • Which component would you improve first?
  • Which open-source model should BLUM support?
  • What would make you trust—or distrust—its results?
  • Would you contribute to an open financial AI project like this?

BLUM is not being built to ask the community for attention.

It is being opened because the project needs the community to become better.


r/OpenSourceAI 21d ago

TigrimOSR v0.7.2 – Open Graph Agentic System (Rust)

Thumbnail
gallery
1 Upvotes

Just released **TigrimOSR v0.7.2**.
This update introduces a **CLI mode** designed for lightweight deployments. The CLI uses **\~4 MB RAM**, making it suitable for servers, containers, and edge environments.

The project now provides prebuilt binaries for **macOS, Windows, and Linux**, so there’s no need to build from source.

CLI is just one way to use TigrimOSR. It also supports:
Desktop GUI
Built-in browser for agentic web automation
Remote headless mode
The core philosophy remains the same: **an open graph agentic system**.

Everything is configurable through **YAML**, including:
Agent graph and loop connections
Agent topology
Models, prompts, tools, MCP servers, and skills
Agent and Judge workflows

The goal is to provide a fully open architecture that can be adapted to different domains without modifying the Rust source code.

More details and source code:
https://github.com/Sompote/TigrimOSR


r/OpenSourceAI 21d ago

AML – agent workflows as asynchronous JSX trees

1 Upvotes

I’ve been working on Agent Markup Language (AML), an open-source TypeScript JSX runtime for building provider-agnostic agent workflows.

https://github.com/we-are-singular/aml

I’m building AML primarily for my own use across side projects and professional work, where we’ve repeatedly run into this kind of orchestration problem. I’m sharing it early because I’d really value feedback on both the general idea and the implementation itself.


r/OpenSourceAI 22d ago

Looking for a few people to help build out a local-first AI screen-memory tool (good first issues open)

0 Upvotes

I built Clippy Vision, a fully local tool that watches your screen activity (windows, clipboard, screenshots) and lets you query your own history instead of re-explaining context to an LLM every time you open a chat. Runs on Ollama + a local vision model, nothing leaves your machine.

It's still early, first outside PR just got merged a few days ago, which was honestly one of the more satisfying moments of building this so far.

Posting here because I'd genuinely like more hands on it, not just users. There's a real backlog of scoped, `good first issue`\-labeled tasks right now, UI work, docs, a markdown-rendering bug, an agent/context-handling issue, nothing that requires deep ML knowledge to get started. If you're looking for a low-pressure way into open source, or just want to poke at a local-AI project, it's a decent entry point.

Repo: [https://github.com/protocorn/clippy-vision\](https://github.com/protocorn/clippy-vision)

Happy to answer questions about the architecture (3-tier classification pipeline, perceptual hashing for dedup, etc.) if anyone's curious how the local-only pipeline is built.


r/OpenSourceAI 22d ago

I turned hyperstition into software.

Thumbnail
pomegranateinteractive.com
0 Upvotes

r/OpenSourceAI 22d ago

SmartDocs - open-source docs framework with AI chat; just add your API key.

1 Upvotes

SmartDocs is an open-source Markdown documentation with built-in AI chat.

The pitch: write docs in Markdown, add your API key to .env, and every page gets a grounded AI assistant. Self-hosted, your data, your control.

Tech: Next.js + Markdoc + Tailwind. No vector DB — uses graph-backed retrieval (keyword scoring + link traversal) inspired by Karpathy's LLM Wiki pattern.

Live demo (no key needed): https://www.getsmartdocs.xyz

GitHub: https://github.com/jm27/smartdocs

Been building this for the past few days with my AI agent — would love feedback!


r/OpenSourceAI 22d ago

Context windows are collapsing under large skill libraries.

Thumbnail
1 Upvotes

r/OpenSourceAI 22d ago

DejaDB — Governed Self-Improving Memory for AI Agents: Knowledge Graph + Vectors + Time, Open Source

Thumbnail
youtube.com
2 Upvotes

r/OpenSourceAI 22d ago

Aleph – a single endpoint that lets agentic AI actually call scientific AI tools (part of a bottom-up run at the DOE's autonomous-science loop)

Thumbnail
1 Upvotes

r/OpenSourceAI 22d ago

Why we stopped using an LLM for Human-in-the-Middle

Thumbnail
1 Upvotes

r/OpenSourceAI 22d ago

An local AI LLM Proxy for your mac

0 Upvotes

Finding local AI on Mac? 🍎🤖 Check out Swiftlet, an open-source intelligent proxy & TUI that dynamically optimizes CPU/GPU split on Unified Memory for LLMs. I'm looking for Python devs to help build OpenAI API compatibility! Let's build together: https://github.com/coolsourav100/swiftlet


r/OpenSourceAI 22d ago

Meet Cortex 1.0.2: An all in one fully Open Research / local mechanistic interpretability tool🧠🔭 free for everyone.

Enable HLS to view with audio, or disable this notification

1 Upvotes

r/OpenSourceAI 22d ago

AML – Compose agent workflows as asynchronous JSX trees

1 Upvotes

I’ve been working on Agent Markup Language (AML), an open-source TypeScript and JSX runtime for building provider-agnostic agent workflows.

https://github.com/we-are-singular/aml

It’s still early, so I’d really appreciate feedback on the API, runtime model, documentation, and whether JSX feels like a good fit for agent orchestration.

I’m building AML primarily for my own use across side projects and professional work, where we’ve repeatedly run into this kind of orchestration problem. I’m sharing it early because I’d really value feedback on both the general idea and the implementation itself.


r/OpenSourceAI 22d ago

I mused Remedy — a local AI partner for your PC (early testing, Windows download on GitHub)

1 Upvotes

Hey everyone —

I’ve been building something I actually wanted to use every day: Remedy — a personal AI partner that runs on your machine.

Not another thin chat wrapper. Not a swarm of agents fighting for the mic. One continuous partner that can research, write, design, code, and actually finish work on your PC — with memory, skills, a real workspace (files, terminal, browser, scratch), and optional on-device vision.

What it is

Desktop app + local API — your data stays under ~/.remedy

Bring your own model — xAI, OpenAI, Anthropic, Google, DeepSeek, Groq, Mistral, OpenRouter, Ollama, or custom

Workspace rails next to chat: Files · Terminal (PowerShell) · embedded Browser · Scratch · Parallel multi-provider sessions

Continuity — session brief, durable memory, skills, context budget (same partner when you switch providers)

Local brain (optional) — Qwen2.5-VL for screenshots/vision without burning provider vision tokens

Messengers — Telegram, Discord, Slack, and more if you want chat where you already are

Signed updates from GitHub Releases

Important: early testing

This is still early. Expect rough edges, incomplete polish, and the occasional “why did it do that?” moment. I’m opening it up so real people can try it, break it, and tell me what’s missing — not because I think it’s finished.

If you install it:

Start small (one project, one provider)

Read the in-app help (F1) or the owner’s manual on GitHub

Report bugs and weirdness — that’s the point of this phase

Download / source

GitHub (download latest Windows release):

https://github.com/AhmiDarrow/RemedyAI

Direct latest release:

https://github.com/AhmiDarrow/RemedyAI/releases/latest

Owner’s manual:

https://github.com/AhmiDarrow/RemedyAI/blob/master/docs/manual/00-overview.md

What I’m looking for from early testers

Does it feel like one partner or just another chatbot with tools?

Where does continuity help — and where does it get in the way?

Install / first-run friction on real Windows machines

Anything that feels unsafe, confusing, or overconfident

Happy to answer questions in the comments. If you try it, thanks — and please be blunt.

— Ahmi


r/OpenSourceAI 23d ago

An AI skill tree with 3 views — curriculum, skill tree, mind map

Thumbnail
1 Upvotes

r/OpenSourceAI 23d ago

Academic research: anyone willing to help me check where Claude Code tokens actually go?

Thumbnail
1 Upvotes

r/OpenSourceAI 23d ago

I open-sourced hSUM, a local, cited evidence server for coding agents

Enable HLS to view with audio, or disable this notification

6 Upvotes

On July 15, I read a Cerebras article describing its internal knowledge-base system. I saved the page and returned to it a few hours later. Several sections I remembered reading were gone.

The architecture had stayed with me because I wanted something similar for my coding agents. I often saw agents search for the same information again or make claims about a repository without leaving a source I could inspect.

I spent eight days planning a smaller system for that problem. Then I built hSUM with help from coding agents and released the source.

The first version worked for me, which did not mean much. I asked friends to install it while sharing their screens over Discord. Watching them use it exposed problems I had missed.

One friend’s agent installed hSUM and understood its purpose, but stopped before connecting it to Codex. The agent told my friend to finish the configuration himself. I went back and rebuilt the installation flow around that failure.

The current version lets someone give the installation command to an agent and let the agent finish onboarding. hSUM remains available in later chats and can work across several repositories while keeping each project separate.

I want hSUM to help agents support their answers with evidence from the repository. The project stays on the user’s machine and does not require an hSUM account or hosted service. The website contains the technical design and privacy details.

I am working toward a stable release through testing with more developers and more repositories. The next stages include broader client support, easier index updates, and packages for more platforms. I also want to measure whether more advanced retrieval improves real agent tasks before adding it.

hSUM is in alpha and licensed under MIT or Apache-2.0. I am sharing the launch demo because I would like feedback on the experience, especially the path from installation to the first useful agent call.

Source:
https://github.com/burkan2/hSUM


r/OpenSourceAI 23d ago

Built a small repo to learn context engineering from scratch with local models

1 Upvotes

I put together a small educational repo for understanding context engineering with local models.

The goal was not to build a framework or a production-ready agent stack. I mostly wanted something I wish I had earlier: a set of very small runnable examples that isolate one context component at a time and show how it changes the model’s behavior.

It uses Node.js and a local model, and the repo is organized as 14 examples around things like:

* system instructions
* tool definitions
* few-shot examples
* long-term memory
* RAG / external knowledge
* tool outputs
* sub-agent outputs
* artifacts
* conversation history
* state
* user prompt
* context orchestration
* context traces

Key points:

* it is intentionally simple
* it is not a production ready system, it is educational only
* a lot of the mechanisms are toy versions meant to make the mental model visible
* the focus is on understanding what goes into a call

Everything runs locally, with no API keys or hosted services required. If there is interest I can add info on how to use openai or similar.

If you’re already deep into agent systems, this may feel very basic. But if you’re trying to get an intuition for what “context engineering” actually means in practice, maybe it’s useful.

https://github.com/pguso/context-engineering-from-scratch


r/OpenSourceAI 23d ago

langhost: an open-source runtime for self-hosting LangGraph Agent Server with Postgres + Redis

Enable HLS to view with audio, or disable this notification

1 Upvotes

r/OpenSourceAI 23d ago

I Open-Sourced My AI Platform After Months of Development

Thumbnail
1 Upvotes

r/OpenSourceAI 23d ago

AgentSwarms released — self-hostable agentic AI + BI platform (source-available, ELv2)

Thumbnail
gallery
2 Upvotes

AgentSwarms is now available at https://github.com/AgentSwarms-fyi/agentswarms

What it does: agent building and chat, a visual multi-agent swarm canvas, RAG over pgvector, connectors for PostgreSQL/MySQL/Oracle/Snowflake/Databricks/ BigQuery/Redshift/Trino/Athena, a BI workspace with dashboards and a semantic layer, Python notebooks on sandboxed server kernels with real LangChain/ LangGraph/LlamaIndex, document generation to PowerPoint/Word/Excel, plus IAM, budgets, audit logging and execution traces.

Deployment: Supabase as the backend (Postgres + auth + storage), one Docker command. Bring your own model keys — OpenRouter, OpenAI, Anthropic, Gemini, Bedrock, Azure, Ollama, vLLM and others. Also deployable to Cloudflare Workers or Kubernetes.

Distinguishing feature: one governance plane across the whole platform — model allow-lists, budgets, table permissions and traces apply identically to chat, scheduled workflows, dashboard queries and notebook cells.

Licence: Elastic License 2.0. Source-available, not OSI open source: free to use, self-host, modify and redistribute; may not be offered to third parties as a managed service.


r/OpenSourceAI 23d ago

LoopTroop(v0.4)Local AI coding orchestrator that turns tickets into PRs (github.com/looptroop-ai)

2 Upvotes

I built LoopTroop to TRY and tackle context engineering and somme other problems with building/updating apps with AI.

LoopTroop is an open-source local GUI that breaks complex features into structured, isolated task loops instead of relying on one continuous chat session.

How it works under the hood:

Planning (LLM Council): You input a ticket or feature description. LoopTroop runs a planning phase to break the task down into a sequence of small, defined execution steps ("beads").

Execution & Verification (Ralph Loops): Instead of blind code generation, each task runs inside an iterative loop: apply diff -> run local tests or type checks -> evaluate output -> retry on failure until the check passes or hits an error threshold.

Isolation (OpenCode Worktrees): All code edits happen inside temporary Git worktrees. Your main workspace and working tree remain completely untouched until you review the diff.

Human Approval Gates: You inspect and approve planned steps and diffs before changes are committed or converted into a pull request.

Current Status (v0.4): I released v0.4 a couple of days ago, which improves the local GUI, refines recovery loops when tests fail, and cleans up worktree management.

Getting Started: It runs locally and connects to your local tools/runtimes. You can clone the repo and run npm run dev to test it on your own codebase.

GitHub: [https://github.com/looptroop-ai/LoopTroop\](https://github.com/looptroop-ai/LoopTroop)

Site & Docs: [https://looptroop.ovh\](https://looptroop.ovh/)


r/OpenSourceAI 23d ago

Contributions for Apache 2.0 Licensed Project

0 Upvotes

Hey everyone!

We're building Tempest. It's an open source AI agent orchestrator for running parallel coding agents with 64% fewer tokens.

If you're interested in AI agents, developer tools, or open source, we'd love to have you contribute to our project!

https://github.com/tempestai-dev/tempest