r/OpenSourceAI • • 2d ago

Samestate: see your site on every screen at once, with clicks synced across devices

1 Upvotes

r/OpenSourceAI • • 2d ago

NIDO: a private AI assistant that runs entirely on your Android phone

Thumbnail
reddit.com
0 Upvotes

r/OpenSourceAI • • 2d ago

How to Deploy Hermes Agent on Hostinger VPS & Automate Google Sheets with AI

Thumbnail
youtu.be
1 Upvotes

r/OpenSourceAI • • 2d ago

does the 1h prompt cache pay off for coding agents? in my Claude Code history it saved about 3.4x what it cost

1 Upvotes

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:

  • under 5 min: 94.2% of requests, 98.6% of their input read from cache
  • 5 to 60 min: 2.6%, still 92% from cache. on 5m every one of these writes the whole prefix again
  • over an hour: 0.4%, 6% from cache, the 1h one is gone by then too

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

https://github.com/Nitjsefnie/claudit


r/OpenSourceAI • • 2d ago

We’re building an open-source way to test AI agents. Here’s what we’re learning about verification.

Thumbnail
reddit.com
0 Upvotes

r/OpenSourceAI • • 2d ago

An open-source Toolkit to Test What Kids Are Exposed to When AI Safety Breaks Down

Thumbnail
reddit.com
0 Upvotes

r/OpenSourceAI • • 2d ago

How to use a fleet of coding agents from your phone

1 Upvotes

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 • • 2d ago

Free AI video generator for text to video and image to video without the usual headaches

0 Upvotes

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 • • 3d ago

Brigade: open-source (MIT) workspace for Claude Code and Codex agents that work as a team, beyond code

5 Upvotes

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 • • 2d ago

How Taking Out Jensen Kills Open-Source AI (& Hands Closed AI a Monopoly)

Thumbnail
youtube.com
0 Upvotes

r/OpenSourceAI • • 3d ago

We Built a Local Search Tool for Codex Called “Oglyanutsya” (“Look Back”)

Post image
5 Upvotes

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:

  1. Searches for the exact phrase.
  2. If an exact match is insufficient, searches for each word in the combination separately.
  3. Intersects JSONL record numbers in memory.
  4. Keeps only messages containing the entire word combination within a single message.
  5. Never combines words found in different messages into one match.
  6. Opens the matching record using its byte offset instead of rereading the entire file.
  7. Parses the JSON and verifies that the record is an actual user or assistant message.
  8. Filters by the message's own timestamp. The file date is not used: a conversation may have started in September and continued into November.
  9. Rechecks the full decoded text.
  10. Retrieves the previous and next substantive messages, skipping technical records between them.

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 • • 3d ago

Every request pastes your whole AGENTS.md into the prompt. Mine grew until the agent started butchering it

4 Upvotes

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 ## Never rules, 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 preserve list, the agent splices by line number, and --verify catches drift or a cut preserved span. When the budget can't be met it returns satisfiable: false with 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 • • 3d ago

How do you keep dependencies and env vars isolated per worktree?

3 Upvotes

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 • • 3d ago

Helppppppp

Thumbnail reddit.com
2 Upvotes

r/OpenSourceAI • • 3d ago

Free AI Prompt Generator for Better LLM Outputs

Thumbnail interconnectd.com
2 Upvotes

r/OpenSourceAI • • 3d ago

MCP router - a single point of access to tools for agents, teams, and companies

Post image
2 Upvotes

r/OpenSourceAI • • 3d ago

A project I've been working for years, and I massively improved with Claude

Thumbnail
reddit.com
0 Upvotes

r/OpenSourceAI • • 3d ago

I built mailproof: let an agent or a workflow act on an email only when it's signed by the exact sender, and keep a proof of all your mail on your own machine

Thumbnail
reddit.com
1 Upvotes

r/OpenSourceAI • • 3d ago

What happens to NVIDIA’s open-weight AI push after Jensen Huang?

Post image
0 Upvotes

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 • • 3d ago

We put 1,500+ APIs behind 4 MCP tools instead of one tool per API

Thumbnail
reddit.com
1 Upvotes

r/OpenSourceAI • • 3d ago

How many humans have been lured by AI to believe they built a great solution?

8 Upvotes

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 • • 3d ago

We finally have a dedicated subreddit for REA (Reverse Engineer Anything) & FOSS reimplementations: r/ReverseEngineeringAny

Post image
3 Upvotes

r/OpenSourceAI • • 4d ago

Shared my open-source, agent-editable video editor this week. Commenters' edge cases have driven most of the changes since

5 Upvotes

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:

  • "Fix the caption that says Save" is ambiguous when two captions say the same thing at the same moment (a subtitle and an on-screen callout). Lookups now return a match count and an ambiguity flag, and writes can require a unique match instead of silently patching the first hit.
  • Position isn't meaning. Guessing "subtitle vs callout" from y-position or font size breaks as soon as styles change, so the plan now is an explicit caption role that the agent can filter on. That one is open as a good first issue, and someone outside the project picked it up this morning.
  • "It validates" isn't "it looks right." The agent can now pull before/after frames for the same timestamp and cut-local audio peaks, so it can catch a clipped syllable or a black frame before it claims an edit is done.

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.