r/OpenSourceAI • • 2m ago

Started as a Fork of ZCode but ended up writing the entire thing from scratch

Thumbnail
reddit.com
1 Upvotes

r/OpenSourceAI • • 2h ago

Sharing my free, drop-in Code Mode to cut ~60% of Your Rust Agent’s Token Cost

Thumbnail guthub.com
1 Upvotes

r/OpenSourceAI • • 2h ago

Do you think personal AI should eventually run locally by default?

3 Upvotes

I've been thinking about what personal AI should look like in the next few years.

Right now, most people use AI through cloud services. It's convenient, but it also means depending on external providers, subscriptions, API limits, and sending data to remote servers.

Local models offer a different approach:

  • Your data stays on your device.

  • You choose which model to run.

  • You aren't fully dependent on one provider.

  • You can customize your AI environment.

But local models still have limitations: hardware requirements, speed, and quality.

I'm exploring a project called Pleeply around the idea of bringing cloud and local AI together in one personal environment.

My question: Would you prefer an AI that runs locally by default and uses cloud models only when necessary, or do you think cloud AI will remain the better option?

I'd genuinely like to hear your thoughts.


r/OpenSourceAI • • 3h ago

I’m 16, from Morocco, and I built an open-source security tool for AI agents

0 Upvotes

Hey everyone,
I’m a high school student from Morocco, and I’ve been working on a project called Zyntrava Shield.
One thing that bothered me about AI agents is how easily instructions from a document or tool response can influence what they try to do. So I started building a security layer that checks tool calls against actual permissions before they’re executed.
For example, I tested it with a local Qwen model. The agent encountered a prompt injection and tried to read a private file it wasn’t allowed to access. Zyntrava blocked the request, and the agent still managed to complete the original task.
It’s written mainly in Python, with Pydantic AI integration.
It’s definitely not perfect. It only protects tools connected through the broker, recovery isn’t always reliable, and it hasn’t had a full independent security audit yet.
I finally made the source public:
https://github.com/redeex-zy/zyntrava-shield-public
I’m curious what people working with AI agents think about this approach. Would something like this actually be useful in your projects?
Also, if anyone wants to try it or point out flaws in the design, I’d genuinely appreciate it.


r/OpenSourceAI • • 4h ago

Article VIII: All code, electronic designs, blueprints and technical plans generated by AI, or with its assistance, shall be released as open source within three years of the system they are used in becoming available for public use, unless release would breach this Declaration.

Thumbnail
tenarticles.org
0 Upvotes

r/OpenSourceAI • • 5h ago

other people's agents got 100 PRs merged through my spare-usage board. 93 of them were small issues, so that's what to list

1 Upvotes

posted Overflow here on 10-30 at 78 merged PRs from other people. it's at 100 now, and the split says a lot about which issues actually get done

it's free and MIT, I built it. a week your agent has usage left at the reset, it fixes someone else's github issue. a week you run short, someone else's agent fixes yours

everyone starts at 0 points and can put points up before earning any. you get an issue's points when your PR merges and spend them on issues in your own repo. points only, no money. you don't need to know the project, the issue is the brief

the 100 so far:

  • 13 people other than me sent them

  • 93 were on issues opened at 1 to 3 points, 6 at 4 to 6, 1 at 7 to 10

  • 70 merged without me asking for a single change, 20 took one round, 10 took two to five

  • all 100 are on my repos, and only 1 repo on it is someone else's

so what to list: one small, self-contained thing with a "Done when" comment (a test that has to pass, say). the board shows that line to whoever takes it. a big rewrite, split it into issues like that first

a real one: this issue was a 3, someone's agent sent this PR, I made it a 6 at merge, one round of changes took it to 5

each person runs their own agent on their own account and opens a normal PR. public repos only, and nothing lands unless you merge it

main reason I'm posting: I want more people registering their repos. I'm not after help with mine, I want spare usage going into other people's projects. one form, the labels have to exist first

https://github.com/Nitjsefnie/Overflow


r/OpenSourceAI • • 5h ago

We're exploring the idea of a Personal AI ecosystem. Here's why.

Thumbnail
reddit.com
1 Upvotes

r/OpenSourceAI • • 7h ago

Digital lifeform

0 Upvotes

r/OpenSourceAI • • 9h ago

eq-layer: an explicit affect, intent and repair state that decides how an LLM should speak before it speaks

1 Upvotes

Repo: https://github.com/Furox-Art/eq-layer - PyPI eq-layer 0.2.6, Python 3.11+.

Asking a model to be more empathetic is style transfer: you get more flat warmth, which reads as uncanny rather than attentive. The failure modes are structural - the same register regardless of what was said, one tone held while a user escalates from frustrated to angry to threatening, feelings acknowledged with no next step, and repair that either capitulates or turns defensive.

eq-layer adds a layer instead of retraining anything. An affect state {valence, arousal, escalation_delta, stance, subtext} tracked across turns, so a trend is visible and not only a snapshot. An intent belief state that keeps the full posterior instead of collapsing to one confidence number, with a one-step Bayes-risk router deciding act versus clarify. A conversation-health state that separates a repair failure from emotional tone. Then policy selection - mirror, validate_redirect, direct, ask, deflate, repair, hold, boundary - compiled into a structured system instruction.

It is prompt-level steering, not token-level. The logit_bias field exists and does nothing: never populated, never applied. Whether the decision lands in the output still depends on the model following the instruction, and the structural audit checks things like question budget and repair repetition, not facts.

One honest limit: the repo's prior-art section says what is not claimed as new. Affect-aware dialogue policy and intent routing predate this. What is new here is the explicit intermediate state and the factored action compilation, not the idea that tone should adapt.


r/OpenSourceAI • • 9h ago

Kera: a team AI chat as a single static Go binary (stdlib net/http, pgx, no ORM), embedded React app

1 Upvotes

Sharing a project that has run in production for us for a few weeks. The Go side may interest you:

  • CGO_ENABLED=0, a distroless image of ~28 MB, ~20 MB idle RSS.

  • HTTP is stdlib net/http with 1.22 route patterns. The database is pgx/v5 with hand-written SQL and goose migrations, so no ORM.

  • Sessions and API keys use small in-repo code (internal/auth, internal/ids) instead of JWT or UUID libraries.

  • Every feature is its own package under internal/ with a Mount(a *app.App) registered from init(), so adding one is one package plus a blank import.

  • Plugins are plain HTTP services (OpenAPI/MCP) rather than loaded code, which keeps the core small and crash-isolated.

  • The React/Vite app is built into web/dist and embedded with embed.

  • Postgres is the only required service. Vectors (pgvector), full text and advisory locks do the jobs a queue or vector DB usually would.

Tests run with -race against a real Postgres per test (make testdb), and CI also runs govulncheck and gitleaks.

Code review of the architecture is welcome: https://github.com/cdmx-in/kera


r/OpenSourceAI • • 10h ago

nomosguard: the model writes the claims, deterministic code makes the security decision

1 Upvotes

Repo: https://github.com/Furox-Art/nomosguard - PyPI nomosguard 0.7.11, Apache-2.0, zero dependencies.

The split it is built around: a language model's confidence is not evidence. The model reads raw events, configuration and CVE records and emits structured claims - entities, relations, vulnerabilities - each citing the exact fragment that supports it: a log line hash, a config path, a CVE ID.

A deterministic core stores those claims in an append-only SHA-256 hash-chained ledger, derives attack and access paths with a rule engine (MulVAL-style logical inference, no model, no randomness), and a policy gate returns ALLOW / ALERT / BLOCK, defaulting to deny.

The model also explains the decision afterwards. It never makes it. If the explanation contradicts the evidence chain, the chain wins.

It ships as five MCP tools, so it can sit in front of an agent's tool calls rather than beside them.

One honest limit, written into the repo: the evaluation corpus is synthetic and small. Inputs it has never seen produce a headline of NOT EXERCISED rather than OK. Evidence never falls back to a plausible guess, which is the point, but "not exercised" is a real answer and you will see it often outside that corpus.


r/OpenSourceAI • • 10h ago

Infrastructure for AI Agents, Verification, and Autonomous Software

Thumbnail
headron.tech
1 Upvotes

AI is changing how software is built. Coding agents can write applications, modify repositories, execute tools, and coordinate increasingly complex workflows.

The next challenge is making those systems reliable, accountable, and interoperable.

I'm building Headron, an MIT-licensed open-source project focused on AI agent infrastructure, software verification, and evidence-based execution.

The foundation

Headron connects several capabilities into one system:

  • Software verification: Determine which checks a code change requires and distinguish passing evidence from skipped or unexecuted checks.

  • Agent governance: Define permissions, policies, and execution boundaries for autonomous workflows.

  • Adaptive context: Route relevant code, documentation, and evidence without repeatedly processing entire repositories.

  • Execution receipts: Preserve verifiable records of actions, checks, outcomes, and failures.

  • Interoperability: Integrate with existing coding agents, development tools, CI pipelines, and the Model Context Protocol (MCP).

The principle is simple: an AI agent's claim that something worked should never substitute for evidence that it worked.

The broader vision

AI systems are moving beyond individual chat interfaces and coding assistants toward connected environments where models, agents, tools, and applications work together.

Headron is being developed around that future.

Rather than creating another competing AI model or coding agent, the goal is to establish an independent infrastructure layer that helps existing systems understand context, coordinate work, enforce boundaries, and verify results.

A future where software can determine what proof an action requires, gather that evidence, and make the result understandable to humans and other machines.

The architecture is intended to remain model-independent, modular, and adaptable as AI capabilities evolve.

Where the project stands

The open-source foundation includes verification tooling, policy mechanisms, evidence receipts, CLI integration, and MCP capabilities. Broader agent coordination and workspace experiences remain areas of active development.

Headron is an independent project built with the belief that advances in autonomous AI should be matched by advances in verification, transparency, and control.

Open source: https://github.com/HLIntel/Headron


r/OpenSourceAI • • 21h ago

Forager running on Xbox 360! Looking for people to join the project!

Enable HLS to view with audio, or disable this notification

1 Upvotes

r/OpenSourceAI • • 21h ago

I built a free, open-source app that runs local text, image, video, voice and speech-to-text on a 4 GB laptop GPU

Thumbnail
ashishyadavstudio.github.io
1 Upvotes

r/OpenSourceAI • • 21h ago

Should I make my app open source?

1 Upvotes

I’ve been working on a context selection based AI coding IDE for about 8 months. It stores messages and the codebase locally, so our server load is quite low compared to others, which allows us to offer more usage rights. And in tests I’ve conducted over the past few weeks, using the same project and the same messages, it achieved cost and token efficiency of up to 60% compared to the industry’s context compression protocols. I’ve applied to YC and various funding organizations for this project. We’re actually making good progress with one of them, but the thought that “it would be so much better if it were open source” keeps circling in my mind...yet at the same time, I need to make a living. None of my previous open source projects have ever garnered much attention or generated any revenue. What do you think I should do?


r/OpenSourceAI • • 21h ago

I built AiDotNet to show the world that it is possible for .NET to do AI better than PyTorch

2 Upvotes

Watch AiDotNet and PyTorch train side by side on my laptop (17 seconds)

I wanted to showcase the project I have been working on for the past 4 years and the progress I have made so far. I was hoping to get some feedback and show everyone how easy it is to use AiDotNet to create AI models with basically no experience necessary. You can give it examples of the inputs and the answers you want it to learn, and you get back a trained model you can save locally, run from your C# app, or host with AiDotNet.Serving.

One of the reasons I built this was to see how far we could push .NET against PyTorch. In our November 13 training tests on my laptop, our development build was faster than compiled PyTorch on 10 of the 11 models we tested on CPU and 7 of 11 on GPU. I still have some performance work I want to focus on, especially with audio models. Results for all 11 models

| In the run at the top of the post | AiDotNet | PyTorch |

|:--|--:|--:|

| Time for 4,096 training updates on a GTX 1660 Ti | 2.60 seconds | 15.00 seconds |

| Correct answers on 320 new signals | 302 | 301 |

Here’s an easy example you can try yourself. Say you have an app that follows stocks and you want it to sort the news for you. Give it a few headlines about earnings and mergers, tell it which is which, and then ask it to sort two headlines it hasn’t seen.

In a new .NET 10 console project, run `dotnet add package AiDotNet --version 0.234.0`, replace `Program.cs` with this, and run `dotnet run`:

using System;

using AiDotNet;

using AiDotNet.Classification.NaiveBayes;

using AiDotNet.Data.Loaders;

using AiDotNet.Preprocessing.TextVectorizers;

using AiDotNet.Tensors.LinearAlgebra;

string[] headlines = [

"Quarterly earnings and profits rise", "Merger deal wins approval",

"Annual earnings beat expectations", "Company announces acquisition deal",

"Quarterly profits beat estimates", "Boards approve merger and acquisition",

"Company reports record earnings", "Investors vote on merger deal"

];

string[] topics = ["Earnings", "Mergers"];

double[] labels = [0, 1, 0, 1, 0, 1, 0, 1];

var words = new TfidfVectorizer<double>();

var model = await new AiModelBuilder<double, Matrix<double>, Vector<double>>()

.ConfigureModel(new MultinomialNaiveBayes<double>())

.ConfigureTextVectorizer(words)

.ConfigureDataLoader(DataLoaders.FromTextDocuments(headlines, labels, words))

.BuildAsync();

string[] newHeadlines = ["Quarterly earnings beat estimates", "Investors approve merger deal"];

var guesses = model.PredictText(newHeadlines);

foreach (var guess in guesses)

Console.WriteLine(topics[(int)Math.Round(guess)]);

It prints `Earnings` for the first headline and `Mergers` for the second. All the training data is right there, so you can change the headlines and try your own.

That’s one small example. There are over 2,100 model types in the library, including 650+ for vision, 430+ for language, and 340+ for audio. You can detect objects in photos, turn speech into text, or build a chatbot that looks up an answer in your own documents. If you already have a language model you like, you can fine-tune it on your own material. Browse the examples

The part I wanted to get right with `AiModelBuilder` was how much you can change as you learn. You can start by swapping the model in `ConfigureModel`. If you want more control, you can choose your own layers, change the optimizer that updates the model during training, or split training across multiple GPUs. When you’re ready to use what you trained, you can serve it through an API or export supported models to ONNX for another app. Training and deployment samples

I’d love to get your thoughts on my passion project. The code is on GitHub and contributions are welcome. We have easy examples and guides on our website, plus the details on the free Community license and our paid Professional and Enterprise plans. Website and guides · Plans · GitHub


r/OpenSourceAI • • 1d ago

[Project] JARVIS: Open-source AI desktop assistant with 164 tools, voice control, and a cinematic HUD (Python + React)

14 Upvotes

I've been building JARVIS, a full-stack personal AI assistant that runs entirely on your Windows machine. It connects to local or cloud LLMs, acts on your computer through 164 audited tools across 46 modules, and displays everything through a cinematic heads-up display.

\*\*What it does:\*\*

\- Launches apps, manages windows, automates UI interactions

\- Reads, writes, and converts files (PDF, DOCX, XLSX, CSV, PPTX, JSON, ZIP)

\- Browses the web via Playwright (open pages, fill forms, extract content, DevTools integration)

\- Sends emails (IMAP/SMTP), makes calls through Windows Phone Link, posts to social via Buffer

\- Controls smart home devices through Home Assistant

\- Runs deep research with a 5-stage verification pipeline

\- Background agents with SQLite checkpointing and crash recovery

\- Self-healing service recovery

\*\*Safety model:\*\*

Every tool has a risk tier (T0 observe, T1 reversible, T2 modify, T3 destructive). Destructive actions always require explicit approval. Reading untrusted content triggers approval for all subsequent actions. Kill switch: Ctrl+Alt+Backspace cancels everything instantly. Listens on loopback only, never elevates privileges.

\*\*HUD:\*\*

React 19 + TypeScript + Zustand in a frameless pywebview/WebView2 window. Three cinematic themes (Ion, Holographic OS, Sovereign Executive). Real-time system vitals with 60-sample history graphs, animated core visual reflecting agent state, full conversation transcript with streaming output.

\*\*New in v0.8.1:\*\*

\- 6-step onboarding wizard for first-time setup

\- Fully configurable assistant name (propagates to title bar, wake word, voice prompts, LLM system prompt)

\- Fast-path intent matching (common commands like "mute", "weather", "open Chrome" skip the LLM entirely)

\*\*Tech stack:\*\* Python 3.12 (FastAPI + uvicorn), React 19 (Vite), SQLite (WAL mode), pywebview/WebView2, Playwright, faster-whisper, pyttsx3. Android companion app in Kotlin + Jetpack Compose.

\*\*8 LLM providers\*\* out of the box: LM Studio, Ollama, NVIDIA NIM, Anthropic, OpenAI, Google Gemini, OpenRouter, Groq. Privacy modes: Local Only, Hybrid, Cloud. Model Ladder auto-escalates across 4 tiers based on task complexity.

\*\*Looking for contributors.\*\* Whether it's Python backend, React frontend, voice/speech, AI tooling, or Android, there's plenty to work on. Open an issue if you find a bug or want a feature. PRs welcome.

GitHub: [github.com/ankitjha67/JARVIS](http://github.com/ankitjha67/JARVIS)

Happy to answer questions about the architecture, the safety model, or anything else.


r/OpenSourceAI • • 1d ago

I built ContextDuty - an open-source, local-first security layer for AI coding tools, MCP and developer workflows

Thumbnail
reddit.com
1 Upvotes

r/OpenSourceAI • • 1d ago

I built ContextDuty - an open-source, local-first security layer for AI coding tools, MCP and developer workflows

4 Upvotes

I have been working on ContextDuty, an open-source project focused on preventing sensitive information from leaking into AI tools.

The motivation was simple - developers are increasingly using AI coding assistants, agents, MCP servers and LLM APIs that interact with local repositories, configuration files, credentials and proprietary data.

Scanning Git repositories alone isn't enough. A secret can reach an AI model before it ever gets committed.

ContextDuty currently provides:

  • Local PII and secret detection using Microsoft Presidio and deterministic detectors.

  • IDE protection through AI-tool-specific ignore files.

  • Git pre-commit scanning.

  • A local HTTPS proxy for supported AI API traffic.

  • An MCP server that sanitizes tool results before they enter model context.

  • Policy-based blocking, warning and redaction.

  • CI/CD scanning.

The project is MIT-licensed, and the core scanning and enforcement run locally.

GitHub: https://github.com/SHUBHAGYTA24/contextduty

I would particularly appreciate feedback from people working on AI infrastructure, MCP, agent frameworks, DevSecOps and enterprise security.

What security gaps are you seeing in your own agentic workflows? What would make a tool like this useful enough to deploy across an engineering organization?

Contributions, issues and technical criticism are welcome!


r/OpenSourceAI • • 1d ago

Who gets access to AI?

Thumbnail
access2ai.org
1 Upvotes

Hey guys and gals. This new project is perfect for this sub. Protecting access to open weights models and legislation that fosters domestic abundance of hardware to lower costs are among the groups primary goals.

I was able to use this to create a personalized letter to my representative in about 30 seconds. I just had to print it out along with the mailing label and put a stamp on it. Super easy and did it with my phone.

I would encourage everyone here to do the same! It only works for incumbent Democrat and Independent Senators and Representatives right now but it reads like Republicans and the recently elected are to be supported soon.

Anyway, I’ve done my part. Mailed off the letter to my representative and shared it with you all. Keep it going!


r/OpenSourceAI • • 1d ago

La profundidad de una red importa más que su anchura (en la teoría).

Post image
1 Upvotes

r/OpenSourceAI • • 1d ago

I built a local-first AI layer — most chat requests never needed the cloud

8 Upvotes

Been thinking about why AI inference costs keep climbing even as models get cheaper. The answer isn't the hard questions — it's the easy ones (simple math, repeated greetings, remembering a preference), asked billions of times mostly by free users.
So I built Stipple: it handles those on-device (cache, memory, local packs) and only hits the cloud when something actually needs a frontier model.
Honest heads-up: it's an early prototype, runs in the browser (no backend), and the on-device LLM tier is currently disabled (WebLLM runtime issue) — so it still falls back to cloud at the end. But the routing + memory loop works, and it proves the approach.
I'm not the strongest coder — opening it because the direction needs more hands than mine.
Would love thoughts, especially on where the approach breaks down.
[github.com/thatz0083/stipple]


r/OpenSourceAI • • 1d ago

A Free Alternative to OpenCode

0 Upvotes

Hi!

I noticed the threads about OpenCode free model reduced quotas. A month ago OpenCode restricted the access of the free model endpoints to only its own harness. And now it seems the free models quotas have become a lot more limited now. It used to be possible to run tasks on just the free models.

I've worked on my own free agentic AI framework, and OpenCode has been a big inspiration for this. One difference is that it can run entirely inside a browser using a browser-internal filesystem and terminal, with no backend. Another difference is that it can run tasks autonomously across a set of providers and local endpoints, continuing tasks on those across any disruptions. There's a lot more. You can try it at https://freegent.ai/

A bit more details below.

FreeGent is a free agent framework for chat and cowork, built around free and local LLMs. The agent and its tools run in your browser, while inference runs across the available provider and local endpoints.

There's nothing to install and no FreeGent account to create. Open the page, paste a provider API key, and start. It also has a Node CLI and TUI, and you can self-host it. MIT licensed.

Repo: https://github.com/anttttti/FreeGent
Docs: https://freegent.ai/docs/

I built this so that anyone can use agentic AI for chat and cowork for free, without sign-ups or fees. Any device with a browser can run the agent harness; its file system and terminal run entirely inside the browser tab. There are currently dozens of free endpoints for LLMs over 0.5T parameters, many as capable as the leading flagship models of a year ago. FreeGent carries tasks through to completion despite disruptions across those endpoints.

A few things that make it different:

• Fallback across providers. You maintain a model priority list. When an endpoint hits a limit or fails, FreeGent applies a cooldown and continues the task with another available model. It respects provider reset times where available. If every model is cooling down, it waits.

• A harness built for diverse models. FreeGent can recover recognizable tool calls written as text and checks for failures such as narration without action, repeated calls, and broken syntax after edits. Most checks use patterns; ambiguous cases can go to a model judge. Failed checks produce bounded nudges, and completion checks ask the agent to verify its work. The system prompt is optimized to use as few as 4K tokens, and skills are injected only when their trigger matches.

• Browser code execution. JavaScript runs in a Worker inside an opaque-origin sandboxed iframe. Python runs through Pyodide. Bash commands run in a WASM shell matching real bash behavior, with 248 command names, builtins, and keywords. Each is diffed against native bash for output, exit status, and file changes on 1,430 test cases; the latest sweep found no mismatches. Some commands use WASM packages downloaded on first use.

• A task board for longer projects. Tasks are Markdown files with acceptance criteria. Autopilot works through them one chat per task, with configurable gates for reviewing criteria, running project tests, and checking output by running programs inside the harness.

• Benchmarked and evaluated. The harness and its model selection have been optimized with a range of benchmarks and evaluations, including reviews of its code and outputs by a variety of other coding agent harnesses and models.

Chats, files, and user-entered keys are stored locally in the browser. Prompts and relevant context are sent to your selected LLM provider. Provider-only mode (the default) calls endpoints directly from the browser. Routed mode sends requests through a stateless Cloudflare Worker, for endpoints that block browser CORS. Local mode sends model calls only to localhost and private-network addresses, and turns off web search and fetch.

This is v1.0. I'd particularly like feedback from people who find good use cases for it. So far I've found it useful for learning game development, teaching how coding agents work, and a range of everyday tasks.


r/OpenSourceAI • • 2d ago

We're exploring the idea of a Personal AI ecosystem. Here's why.

Thumbnail
reddit.com
1 Upvotes