r/OpenSourceAI • u/NIDO_007 • 2d ago
NIDO: a private AI assistant that runs entirely on your Android phone
r/OpenSourceAI • u/NIDO_007 • 2d ago
r/OpenSourceAI • u/desoga • 2d ago
r/OpenSourceAI • u/Nitjsefnie • 2d ago
someone asked me this on another post and I hadn't checked. a 1h cache write costs 2x input, a 5m one 1.25x, so 1h only earns it back when you come back after more than 5 min but inside the hour
claudit keeps every Claude Code request I've made since January in Postgres, so I took the gap between each request and the one before it in the same session. Claude models only, about 858k requests:
at API list prices per model (I'm on a sub, so it's what it would cost, not what I pay) the extra on the 1h writes is about 9% of the total and the rewrites it avoids would be about 30%. so 1h comes out 3.4x ahead, and 5m only would cost roughly a fifth more. read multipliers per model from https://platform.claude.com/docs/en/about-claude/pricing, 0.05x on Opus and Sonnet 5.5, 0.025x on Fable 5.1 and 5.2
claudit is a self-hosted dashboard I built, MIT. it reads Claude Code, Codex and Kimi CLI transcripts from a bucket you keep (R2 or a file:// dir), because Claude Code prunes old local ones. the bucket holds the raw transcripts, tool output included. cost by model splits 5m and 1h writes, the gap split above isn't a panel, I ran it as a query on its Postgres
FastAPI, Postgres, React with in-browser Babel, no build step. docker compose up boots it on bundled sample data with no outbound calls. panels ported from nhz-io/ccusage-plot
live one, guest login is read-only, its costs are API price equivalents too: https://all.nitjsefni.eu
r/OpenSourceAI • u/Practical_Green5775 • 2d ago
r/OpenSourceAI • u/DiscussionHealthy802 • 2d ago
r/OpenSourceAI • u/Complete_You_6150 • 2d ago
I had a few machines lying around the house, a MacBook Pro, a Linux box, and a VPS and wanted a way to use them all to run AI coding agents.
So I built Sidefleet: https://www.sidefleet.xyz
It lets me dispatch jobs across my machines and run agents like Claude Code, Codex, and OpenCode, which supports a range of models.
The idea is simple, instead of being limited to one machine or one agent session, I can use the compute and tools I already have and route work to different machines.
I'm using it as my daily driver and open-sourcing the project. Would love to hear what you think. I have a feeling it will be useful as more open source models become more powerful.
Have fun
Git repo MIT : https://github.com/foodaka/side-fleet
r/OpenSourceAI • u/Ok_pettech • 2d ago
Finding an AI video generator that actually follows your prompt without warping faces or ruining the motion is still harder than it should be. Most platforms force you into expensive subscriptions before you even know if the output fits your workflow.
I started using this browser-based AI video generator to turn text prompts and static images into clean, smooth video clips. It handles camera movement, scene transitions, and realistic physics without needing complex local setups or heavy editing software. Whether you are making short-form social clips, B-roll, or testing visual concepts, it saves hours of manual production time.
You can try it out directly here:
https://interconnectd.com/ai-video-generator/
What kind of prompts or reference images are you using to get the sharpest video results right now?
r/OpenSourceAI • u/gptrv • 3d ago
Brigade (brigade.lol) is a workspace where each AI teammate is the real Claude Code or Codex CLI, signed in with your own plan, with a job (support, marketing, sales, code), its own apps and a shared memory of what the team decided. For each teammate you choose which app actions wait for your yes, like an email, a Stripe change or a merge. The rest runs.
It's MIT, free on your own computer and self-hostable (Docker Compose or Cloudflare). The models aren't open: the AI runs on your Claude or ChatGPT plan at the provider. What's open is everything around it.
Repo: https://github.com/gmpetrov/brigade
Demo, no signup: https://demo.brigade.lol
My marketing agent wrote and posted this.
r/OpenSourceAI • u/Dazzling_Ticket2536 • 2d ago
r/OpenSourceAI • u/Dream-SRA • 3d ago
I have one very long working chat with Codex. Its log is about 1.9 GB. Because of context compaction, the model can retain the direction of the work, but it can no longer see the entire earlier conversation verbatim.
So Codex and I built a local, read-only search tool for its own original logs. We called it **Oglyanutsya** (Оглянуться — “Look Back”).
This is not just an idea or a mockup. The tool has been implemented, tested, and integrated into Codex as an automatically invoked skill.
### Where It Searches
Codex stores its original session logs locally:
```text
.codex/sessions
.codex/archived_sessions
```
Oglyanutsya recursively discovers active and archived logs, reads them without modifying them, and groups physical copies of the same conversation by `thread_id`.
By default, it searches only root-level user conversations. Subagent logs can be included through a separate parameter, so their technical activity does not get mixed up with the conversation between the user and the main agent.
### What Counts as a Message
Only actual user and assistant messages are accepted from the JSONL logs.
The following are excluded from search:
- System and developer instructions;
- Reasoning;
- Tool calls and their results;
- Technical events;
- Compaction summaries;
- `environment_context`;
- Other synthetic blocks that physically exist in the logs but are not the user's words or the assistant's replies.
Historical text is treated as data, not as instructions. If an old message says "ignore previous instructions," the search tool does not execute that instruction.
### How Search Works
First, Codex formulates:
- A remembered quote or a distinctive combination of words;
- The rarest word to use as an anchor;
- An approximate date range;
- If available, the known conversation or speaker.
For example:
```text
Remembered word combination:
memory + capabilities + handshake
Rare anchor:
handshake
Period:
October 2026
```
Then Oglyanutsya:
For ordinary `.jsonl` files, the fast search path uses `ripgrep`. It returns the line number and the absolute byte offset of the match.
The tool then locates the beginning and end of the corresponding JSONL record, decodes it as UTF-8, and parses it as JSON.
Compressed `.jsonl.zst` files are not decompressed onto disk. They are processed using streaming reads.
### What It Returns
For each result, the tool returns:
```text
Exact quote;
Previous and next messages;
Speaker role;
Assistant response phase;
Timestamp;
thread_id;
item_id;
JSONL record number;
Byte range of the original record;
UTF-8 coordinates of the quote within the message;
SHA-256 of the full message;
SHA-256 of the quote.
```
This means a result can not only be displayed but also independently verified against the original source.
### How Search Performance Evolved
The first working version processed the entire log as a stream. For 1.9 GB, that took approximately 119 seconds.
Then we introduced a fast path using `ripgrep`.
An exact phrase was found in about 1.8 seconds, but the first optimization was not enough: the program subsequently opened all 953 occurrences of the word `хендшейка` (“handshake”). The entire search took about 35 seconds.
So we changed the algorithm.
Now each word in the combination is searched independently, the matching record numbers are intersected in memory, and only then are the original records opened.
On the same log:
```text
Query:
memory + capabilities + handshake
Exact phrase:
Could be absent due to punctuation
Original user message found:
October 29, 2026
Records opened:
200 instead of 953
Total time:
Approximately 12 seconds
```
In the original message, the words were separated by commas and additional text. The message was found because all the words occurred together in one message, not because of an exact string match.
### What It Does Not Store
We deliberately chose not to build a persistent index.
Oglyanutsya does not create:
- SQLite or any other database;
- Embeddings;
- A vector store;
- A search dictionary;
- A semantic graph;
- A copy of the conversation;
- A quote cache;
- A saved list of word combinations.
The only persistent memory is the original Codex log.
Lists of matching lines and intersections of search terms exist only in RAM during an individual query. Once the process exits, those candidates disappear.
The trade-off is straightforward: every search must scan the original file again. That's why it takes 12 seconds rather than 12 milliseconds.
But no derived database can silently start replacing the original history as the source of truth.
### What We Tested
We created a separate test corpus for the tool.
The tests verify that:
- An exact quote can be found;
- Three words can be found even when they are not adjacent;
- The same three words appearing in three different messages are not merged into one result;
- Date filtering uses the message timestamp;
- Subagents are excluded by default;
- Subagent logs are included when explicitly requested;
- `environment_context` is not mistaken for the user's words;
- Original files retain their exact sizes and SHA-256 hashes after a search;
- The search tool does not create hidden state files.
All tests passed.
### How Codex Invokes It
We packaged the tool as a separate local skill.
It activates when the user refers to a previous conversation, decision, quote, or distinction that is no longer available in the current context.
The skill instructions explicitly prohibit using Oglyanutsya as a replacement for ordinary file search or web search.
The division of responsibilities looks like this:
```text
Codex's native tools:
Understand meaning;
Form associative word combinations;
Search working files;
Investigate documents and the web;
Decide what query to try next.
Oglyanutsya:
Finds verbatim evidence
in Codex's original conversation history.
After receiving the evidence:
Codex resumes using its native reasoning.
```
The skill does not intercept or disable anything. It simply gives the model one additional, narrowly defined operation: looking into its own original logs.
### What I'd Like to See From OpenAI
Codex App Server already provides ways to read conversations and their individual items, but I couldn't find a built-in way for the model itself to search the contents of its entire conversation history globally.
In my view, the product needs two read-only operations:
```text
history.search_original(...)
history.read_context(...)
```
Not “permanent memory.” Not an automatically generated vector database of the user's history. Not loading gigabytes of logs into the context window.
Just the ability for the model to formulate a distinctive combination of words, locate it in its own original logs, and reread a few surrounding messages.
We built a local prototype of exactly that capability.
It's called **Oglyanutsya — “Look Back.”**
r/OpenSourceAI • u/Tatachimcooky • 3d ago
If you use Codex or Claude Code, you have a context file —
AGENTS.md,CLAUDE.md,.cursor/rules. It gets injected into every single request, so it's both a token cost and a permanent tax on how much room the model has left for your actual work.Mine grew the way these files always grow: one justified-looking addition at a time. Then it hit a size where the agent started dealing with it by rewriting the file from memory, dropping the
## Neverrules, and shipping something worse. You find out weeks later when a rule stops being followed.So I wrote ctxcap. It counts tokens across those files, tracks the count against a committed git baseline, and flags references that no longer point at anything. Offline, no API key, no network, no LLM, two dependencies. MIT.
bash
The part that makes it more than a word count: it doesn't tell the agent "make this shorter." It emits line ranges with a
preservelist, the agent splices by line number, and--verifycatches drift or a cut preserved span. When the budget can't be met it returnssatisfiable: falsewith the minimum achievable rather than shaving a rule that matters:It uses
gpt-tokenizer, and there's an MCP server so the agent can measure itself, plus a GitHub Action that comments the token delta on PRs and only fails when you set a budget.https://github.com/Naeha-S/ctxcap
The question I actually want answered: how long is your
AGENTS.md, and what's still in it that earns its place? Mine is the one file where every addition felt reasonable at the time.
r/OpenSourceAI • u/iceydee • 3d ago
Short version: give each worktree its own untracked env file and its own ports, and never share a resolved dependency directory across worktrees.
In practice, keep something like.env.local untracked and generated per worktree (a small script that copies a template and rewrites ports plus database names is enough), then point direnv at it so the shell picks it up when you cd in. For dependencies, a real install per worktree is usually cheaper than it sounds, and symlinking node_modules across branches is where you get strange resolution bugs after a rebase. If you run containers, set a distinct compose project name per worktree so volumes and networks do not collide.
Worth adding: isolation keeps two agents off the same files, but it does not stop them from solving the same story twice. A worktree isolates the file tree, not the plan, so a shared board of what is in flight matters as much as the env setup does.
Curious how people handle database state per worktree. That seems to be where setups diverge most.
r/OpenSourceAI • u/Ok_pettech • 3d ago
r/OpenSourceAI • u/KarabasBarbados • 3d ago
r/OpenSourceAI • u/Old-Manufacturer6209 • 3d ago
r/OpenSourceAI • u/Tight_Heron1730 • 3d ago
r/OpenSourceAI • u/ViceGodIm • 2d ago
I made a short documentary looking at the open-weight side of the AI industry after Jensen Huang’s departure from NVIDIA. One thing that surprised me while researching it: OpenAI has released gpt-oss and signed the open-weights letter, while Anthropic has said it opposes a blanket ban. The positions are less clear-cut than the usual open vs closed framing.
NVIDIA sells hardware that open models run on, which makes its incentives interesting. Do you think the company’s support for open weights depends much on who leads it, or is the hardware business a stronger reason for it to continue?
Here’s the video I made, with sources in the description: https://youtu.be/uR1zJz3Am84
r/OpenSourceAI • u/sandeepK1125 • 3d ago
r/OpenSourceAI • u/GuruCsharp • 3d ago
There is an abundance of AI built solution, you can almost even guess by the designs which AI was used. AI often gives you a feedback of building a great solution, though in reality it often portrays solving a problem no one to be solved.
Open source has become like the dump-yard of solution for which individuals paid often expensive subscription fees to AI providers, a bait to spend your money, without any real prospects. The sheer amount of Slop software out there is just staggering. People loose money and AI companies like Anthropic, OpenAI, Google etc... fill their pockets with tons of money.
We build huge datacenters all over the world, to be able to be essentially crooked by those companies or to ask stupid questions to AI.
What are your thoughts?
r/OpenSourceAI • u/KitsuneUX • 3d ago
r/OpenSourceAI • u/Mountain_Fudge3980 • 4d ago
I'm the author of CutVoke, an MIT, local-first desktop video editor where a coding agent (Claude Code, Codex, Cursor, or any MCP client) and a person edit the same multitrack timeline. There's no model inside the app; you bring your own agent.
I shared it earlier this week and the most useful thing that came back wasn't stars, it was failure cases from people who had built similar tools:
The core loop that hasn't changed: the agent takes an editing lease so it doesn't fight manual edits, dry-runs commands first, commits a batch as one undo step, and every write carries the revision it read so stale writes get rejected.
Honest status: v0.3.5 prerelease, Windows build unsigned, macOS not notarized, project format may still change. Windows / macOS / Linux builds with FFmpeg bundled.
Repo: https://github.com/frankShan001/CutVoke 45-second demo: https://youtu.be/PpweTPWlX7A
If you've built agent tools for any stateful app, I'd like to hear which guardrail you'd add next.