Hello all! Please fill this out to help get rid of the lard that lives in his mother’s basement!

https://www.change.org/opensource

Thanks!

Some series do not move around a fixed value: they alternate between

calm and agitated periods. A return series has this shape, and so does

the vibration of a joint whose load changes over time.

The level of the series is one question;

the volatility of the series is another.

GARCH answers the second.

link git hub : https://github.com/tatopenn-cell/Dense-Armor

pypi: pip install dense-armor

#machine-learning #change-point-detection #opensource #variance #volatility

Disclosure: I work on an LLM gateway (starunion.net), so pricing changes are literally my day job. Posting the analysis, not a pitch.

OpenAI released GPT-6.1 Terra on Oct 26. API pricing:

- Input: $1 / 1M

- Cached input: $0.05 / 1M

- Output: $5 / 1M

That's ~50% under GPT-5.6 Terra and GPT-6.1 Sol.

The interesting part isn't the discount, it's what the discount is pointed at. Terra is positioned around visual reasoning and computer use — screen reading, form filling, clicking through internal tools. Those workloads are token-hungry by nature: the model looks, acts, re-checks, repeats. At half the price per token, a lot of "cool demo" automation becomes economically boring — which is the point where it actually gets deployed.

Reported eval numbers: Agents' Last Exam (medium reasoning) ~15 points over GPT-5.6 Terra at roughly 1/3 the cost. Error-induction test: low tier 53.6% → 16.7% error rate.

Caveats worth flagging:

1. It's gated to ChatGPT Work / Codex — not a general model picker entry.

2. No UAE inference residency support, so check regional compliance if that applies to you.

3. Vendor benchmarks ≠ your ERP. Internal approval flows and permission popups are where these models still fail.

How I'd evaluate it: pick one task you already owe someone this week, write explicit acceptance criteria (what counts as done, what must not happen), run it, then record four numbers — time to completion, manual corrections, quality vs. the criteria, actual token spend. If corrections don't go up while cost drops, it's a keeper for that task class. If it breaks on complex navigation and permission dialogs, cheaper doesn't help.

Curious: for those running computer-use agents in production, what's actually been the blocker — model capability, or the cost of the verification loop around it?

Hi everyone, I maintain sift-light, an open-source local project search and source-inspection tool for AI coding agents. It offers MCP and native integrations, returning bounded results so agents can inspect relevant code.

We just released 1.1.2-1. A contributor discovered that enabling tools in our Pi integration could change the beginning of the system prompt and reduce prompt-cache reuse. This update keeps that prefix stable and preserves search guidance when another extension supplies the system prompt. You need Pi 0.86.0 or newer.

We also added DeepSeek Harness 0.2.1-rc.3 support, including a native search tool and search-policy integration. The cache fix is specific to our Pi integration; behavior in other clients depends on their own prompt and tool handling.

Thanks to the contributor of PR #123 for identifying the issue and helping us fix it. If you try the update, feedback and reproducible bug reports are welcome.

GitHub: https://github.com/lightsifter/sift-light Release notes: https://github.com/lightsifter/sift-light/releases/tag/v1.1.2-1 X: https://x.com/Bryang168

Hi everyone,

I'd like to share N-Zik, an open-source (GPLv3) YouTube Music client for Android. It started as a fork of Kreate and grew into a community project, with performance improvements, UI/UX refinement, bug fixes, and new features built with long-term support in mind.

What it does

• Streams from YouTube Music premium quality unlocks automatically if you connect a YouTube Music Premium account
• Offline: smart auto-caching + real downloads (individual tracks or whole playlists), with a dedicated download quality setting
• Advanced lyrics: fetch, word-by-word sync, edit, and translate in real time
• Song recognition (Shazam-like) and voice search
• Available in 30+ languages via community translation (Crowdin)
• Listening stats + a "Rewind" feature with yearly/monthly recaps
• Listen Together: live listening sessions with friends (N-Zik is an officially supported MetroServer host)
• Desktop companion app (Windows/Linux) to control your library and playback from your PC (very very early stage not mean for use rn)
• Home-screen widgets, Android Auto/TV (still need improvements)/tablet support, Discord Rich Presence, Last.fm scrobbling
• Multi-profile, automatic settings + database backup, parental controls, hidden songs

Where to get it

• GitHub (all builds: 64/32-bit, FOSS, and minified builds for low-end devices): https://github.com/N-Zik-Group/N-Zik/releases
• F-Droid (FOSS build): https://f-droid.org/packages/com.nevar.nzik.foss/
• Official website: https://n-zik.vercel.app
• Discord: https://discord.gg/bneHC7QRje

Honest notes

• N-Zik may not be as stable as the original Kreate yet. If you need a more mature option, Metrolist, VIVI Music, or RiPlay are solid alternatives.
• It's a side project that grew bigger than expected. I use generative AI to assist with the code (structured with the BMAD Method), but everything gets reviewed and tested before it's pushed not shipping blind.
• The project has no affiliation with YouTube or Google LLC.
• i'm currently restructured release, new build aren't out yet still finishing other issue

If you try it, I'd love to hear what works and what doesn't feedback and issues are very welcome on GitHub.

SOURCE INTEGRITY: [ PRIORITY ]
AUTHORSHIP: [ HUMAN ]
INTERPRETATION: [ PROVISIONAL ]
EVIDENCE: [ REQUIRED WHERE RELEVANT ]
DISAGREEMENT: [ PERMITTED ]
CORRECTION: [ ENABLED ]
FRAMEWORK: [ REPLACEABLE ]
FINAL AUTHORITY: [ NOT CLAIMED ]

ONE SHARED LANGUAGE.
MANY PERSPECTIVES.

> _

I've been working on RAG and agent memory, and the recurring problem is trust. An agent saves something it learned, and later nobody can say where it came from, whether it is still true, or what it believed at an earlier date. We're building an open source Python library for this: OntoGr Agent Memory (https://github.com/ontogr/ontogr-agent-memory).

- Grounded ingestion and extraction: Messages, documents, tool outputs, events, and record rows become episodes. Entities and facts are extracted in two separate passes, and every fact carries a verbatim quote from its episode.

- Per-tenant ontology: Each tenant defines the entity and relation types it allows. A model can propose additions, but a person approves every change.

- Reversible entity resolution: It uses the cheapest evidence first and asks a model only about ambiguous pairs. Every merge can be undone.

- Two time axes: Valid time and system time let a read ask what was true on a date, or what the system believed on that date. A new value closes the old version instead of overwriting it.

- Contradiction rulings: Rules, an optional model judge, and a person's decision settle conflicts, and the person's decision overrides both. A failed judge call is never stored as "no conflict".

- Traceable and auditable: Every fact traces back to a quote and an episode, and every temporal write goes into a hash-chained ledger. Per-tenant grants, an audit log, previewed and resumable forget and erase, and deterministic export are built in.

- Four-lane retrieval: Vector, keyword, entity, and graph lanes are fused with reciprocal rank fusion. The result is a token-budgeted context block that reports which lanes failed.

- Fits your stack: It runs on FalkorDB or Neo4j, with pgvector or Postgres if you want them. A background consolidation job deduplicates, summarizes, scores, and archives. You bring your own LLM and embedder.

Repo: https://github.com/ontogr/ontogr-agent-memory

I'd like feedback on the time model and on which benchmarks you'd want to see first.

I use both Claude Code and Codex, and every time I switch I end up re-explaining the same preferences. CLAUDE.md and AGENTS.md help for rules I can write down. But most of what I want, I never wrote down; I just kept making the same correction.

Nebula is a small self-learning memory layer for both agents. It picks up patterns from the corrections you already make, and nothing applies until you approve it.

The example in the video: I cleared node_modules in one stale project, a Rust target/ folder in another, and build/ in a third, all in Claude Code. Later, Codex hit a full disk and suggested the same cleanup for my other inactive projects. Once I approve that lesson, both agents handle it that way.

How it works:

- A skill plus hooks for Claude Code and Codex, sharing one local SQLite file

- Python standard library only, no model calls, no background process, nothing leaves your machine

- Lessons stay candidates until you approve them, so a one-off remark (or a prompt injection) can't turn into a standing rule

- Lessons keep their reasons and exceptions, and you can correct, pause or withdraw them

Honest status: the engine and demo work and have tests. End-to-end runs on both agents are still being validated, and the video is an illustrative animation, not a screen recording.

I'm looking for contributors. There are good-first-issues up, and I'd especially like help with adapters for other agents (Cursor, Gemini CLI, Aider). I'd also like to hear where you think this beats or loses to a plain markdown file.

I'm the author; happy to answer anything.

Repo: https://github.com/svssathvik7/nebula

SUB/WAVE turns a Navidrome music library into one internet radio station. An AI DJ picks the tracks and talks between them with idents, time checks, weather and intros, and everyone tuned in hears the same Icecast stream at the same time. The LLM can be local Ollama or a hosted provider, and it runs with one docker compose up -d on a Linux host.

The video shows the eight player skins from the latest release (v1.27.0): Classic, Unit SW-9, Drift, Subamp, TTY, Platter, AXO-1 and Cipher-3. They all read the same live stream, so a skin only changes how a listener sees the station. A few I had the most fun with:

• TTY draws everything as characters on one canvas grid. Its focus mode renders ASCII scenes driven by the audio analyser, which follow the station's time of day and overlay its real weather. There's also a scope pane with a block spectrum and a braille oscilloscope.
• AXO-1 is an isometric hi-fi stack.
• Cipher-3 is a rotor cipher machine you type song requests into.
• Unit SW-9 set the look the others borrow from: brushed metal, keys with travel, dot-matrix display glass.

Themes sit on top of the skins. Two new ones are Phosphor (green on black, scanlines, bloom) and Riso (blue and pink on cream, halftone, misregistered print). Custom themes are plain JSON files.

The hardest part was Safari. The theme "finish" was an SVG filter over the whole player, and WebKit re-ran it on the CPU on every repaint. That had AXO-1 at 13 to 19 fps and made iPad stutter on every skin. Safari now keeps the texture and skips the finish, and each skin got its own Safari pass after that.

It's mostly TypeScript and Python, with Liquidsoap and Icecast handling the audio.

Repo: https://github.com/perminder-klair/subwave

Docs and setup: https://www.getsubwave.com

Screenshots of every skin: https://getsubwave.com/news/dress-up-your-radio

Happy to answer questions about how any of it works.

hey — i made a video editor that has no gui and gets driven entirely by ai agents over mcp, and i want to talk about the angle that's different now: titles, colour grade and particles are all just tool calls, and the agent can render a single frame to visually check its own work before exporting the whole thing.

it's called kimo. free, open-source (mit), and it's basically one 15 mb cpu-only rust binary that'll run on a 2 gb box. no tiling ui, no mouse, no timeline to point at — the coding agent (codex, cursor, opencode or whatever mcp client you're on) calls operations directly: cut, trim, keyframe, titles and captions, colour grade, tracking, particles, audio, export. and the bit i'm most proud of right now is that the agent can ask it to render a frame and look at it to verify the grade, the titles, the particles — that feedback loop is what actually makes this usable instead of just another ffmpeg wrapper.

built it myself, i'm a college student. i've used it to make a few videos end-to-end from an agent but i know it's rough — the tracking isn't quite there on fast motion, the particle system is barebones, captions positioning is manual, and the docs are thin. i'd rather hear what actually breaks for people than pretend it's polished.

if you want to try it and tell me what falls apart: https://getkimo.tech https://github.com/naman-sharma12345/kimo

thanks in advance, and yeah i'll be around to answer questions (but please tell me what broke rather than just saying it's cool, i actually need that).

sharing a project in case it's useful as a testbed. it's a civilization sim where every person learns from what happens to them with a small tabular q-learner, picks up words from family and neighbours, and passes some of it to their kids. tribes split and drift apart over long runs.

why it might be handy for experiments: - one rust crate with no i/o, compiled to wasm for the browser and native for the cli - runs are deterministic, the same seed and tick count give the same world - a headless runner: cargo run --release -p headless -- --seed 42 --ticks 6000 --every 1000, or --sweep-seeds 8 for a world-health sweep over several seeds - adding a new action is one file plus one line (docs/ADDING_ACTIONS.md)

it's all mit. if you try swapping the learner for something else i'd love to hear how it goes.

source: https://github.com/1homsi/thehumanbox browser version: https://thehumanbox.com

I recently built a complete RAG Evaluation Framework from scratch: a 43-question test dataset, 6 retrieval metrics, 5 generation metrics, and one final report that shows exactly where a RAG system is strong and where it breaks. We start with the concepts, explained with simple worked examples, and then walk through the code line by line.

What this covers:

• Why retrieval and generation must be evaluated separately
• How to build an evaluation dataset with expected answers, graded pages and key facts
• Retrieval metrics: Hit Rate@K, Precision@K, Recall@K, MRR, MAP and NDCG@K
• The difference between one question (RR, AP) and many questions (MRR, MAP)
• Generation metrics: Faithfulness, Hallucination Rate, Answer Relevance, Context Relevance and Answer Correctness
• How to use an LLM-as-a-judge that only counts, while your code does the maths
• How to save results safely and turn them into a clear evaluation report

KEY TAKEAWAYS:

• No single metric tells the whole story: Hit Rate was 1.00, but Recall, MAP and NDCG showed where pages were missed or buried
• Precision@5 looks low (0.34) for single-fact questions, so compare systems with each other, not with 1.0
• Faithful does not mean correct: an answer can be backed by the chunks and still miss the key facts
• Retrieval scores and answer quality are not the same thing
• Our Cohere-reranked pipeline scored MRR 0.95, MAP 0.87, NDCG@5 0.91, Faithfulness 1.00 and Answer Correctness 0.97

TECH STACK: Python, Qdrant (vector database), Embeddings (3072-dimension), Cohere Rerank, LLM for answers + LLM-as-a-judge, pdfplumber (checking pages in the PDFs)

• 5 real payments documents: PCI DSS, CPMI-IOSCO PFMI, CPMI cross-border roadmap, Stripe payment methods guide, FCA approach document

• Full Code (clone it, fork it, break it): https://github.com/saurabhkamal/RAG-ReRanker-Comparison

• Full Video Walkthrough: https://youtu.be/_bVzDU-yBnA

Would love to hear.

Since the OG open-source subreddit decided to be a bunch of AI and xenophobic {insert slur of your liking} here's my AI project.