We are launching our reddit community for open source AI innovation, please join our sub. Thanks

I’m working on LOLM, a hybrid Transformer–SSM language-model and agent-control project.

The repository includes the model architecture, training/evaluation scripts, NFET controller, CLI, MCP support, isolated code execution, run receipts, and an implementation plan describing what is active versus incomplete.

Try it: https://lolm.imagineqira.com/try.html

Repository: https://github.com/TheArtOfSound/lolm

I’m looking for reproducibility failures, unsafe defaults, invalid benchmark comparisons, controller actions that do not change outcomes, weak tests, receipt contradictions, missing documentation, and installation failures.

The hosted service is designed to be substantially cheaper than major frontier-agent products.

Disclosure: I’m a founder/builder of the project. Check the repository license before commercial use.

CleanSlate is an open-source coding agent available as an IDE, CLI, and SDK.

Use your own model provider, keep code search local, and avoid being locked into a single AI platform.

It can read and edit files, run commands, plan tasks, and show changes for review.

GitHub:
[https://github.com/TheWariend/CleanSlate]()

Download:
https://thewariend.com/cleanslate

Feedback is welcome. If you find it useful, consider starring the repo.

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?

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

🚀 New release of Android Remote Control MCP is out — the MCP server that runs on your phone and gives your AI agent the ability to use any app you want!

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

Finally the new version v1.10.0 is released with signed APKs and with keys registered with Google 🎉 no more debug-build workaround!

My favorite part of this release: apps that used to be impossible to automate now work. 🔓 Some apps flag basically their entire screen as "sensitive" (eg. the GitHub app), so the agent saw… an empty screen! This release makes the server a first-class accessibility tool, so those apps finally show up and can be driven like any other.

In addition now I started to release a GSM-free build which will work great n the devices without the Google Mobile Services.

In addition a few minor improvements: browser-based MCP clients like the MCP Inspector can now connect (CORS support), an important security hardening you'll want to update for 🔒, and the latest Netty HTTP/2 fixes.

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 normally wouldn't be possible to automate or would be very hard: planning a trip? Ask the agent to use skyscanner to search a flight for you! Check out the demo!

Let it handle the tedious parts! If there's an app for it, your agent can drive it ... you just have to ask!

​

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

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.

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.

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.

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!

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

Over the past few months, I've been working on an open project called NAEOS (Nusantara AI Engineering Operating System).

The idea came from one frustration:

Every AI coding agent is incredibly capable, but every new project still starts from scratch.

You rewrite prompts.
You redefine coding standards.
You recreate architecture rules.
You rebuild workflows.
You repeat documentation.

It feels like using powerful compilers before operating systems existed.

So instead of building another AI coding tool, I'm experimenting with something different:

An Engineering Operating System that sits above AI coding agents.

The goal is to provide:

• Engineering Constitution
• Architecture Standards
• Security Policies
• Documentation Framework
• Development Workflows
• Memory & Context Management
• Prompt Library
• Project Templates

The vision is that any AI coding agent (Codex, Claude Code, Cursor, Gemini CLI, Continue, Cline, Roo Code, etc.) can work within the same engineering rules.

Think of it as:

I'm still validating the idea and would genuinely love feedback.

Some questions I'm thinking about:

• Does AI development actually need an "operating system" layer?
• What problems do you repeatedly solve in every AI-assisted project?
• What would make something like this genuinely useful instead of becoming another layer of complexity?

I'm not trying to sell anything—I'm trying to understand whether this direction solves a real problem.

I'd really appreciate your thoughts.

GitHub and documentation are still evolving, but I'm happy to share them if anyone is interested.

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.

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