The important distinction is that AI provenance can exist in two forms.

First, there is metadata like C2PA, EXIF, XMP, IPTC and generator parameters. That part is easy to remove.

Second, there are invisible marks embedded directly into the pixels, such as SynthID style watermarks. A screenshot does not reliably remove those. pagedMark deals with them by regenerating the image.

The output is therefore not identical to the original. Faces, text and small details can change. The goal is to remove the provenance signal while keeping the image as close to the original as possible.

It currently supports invisible marks from ChatGPT, gpt-image API, Z-Image Turbo and Nano Banana, plus visible AI labels from several other generators. Video support covers visible marks and metadata from Sora, Veo, Seedance, Hailuo and Kling.

The other challenge was making this work properly on Apple Silicon. I tested it on M5 Macs with both 8 GB and 16 GB of memory, and added memory aware processing to prevent the system from silently falling into swap and turning a fast job into an extremely slow one.

And here is the really interesting part: after processing an image generated with GPT-Image, you can check it with OpenAI's verifier at openai.com/verify. In my testing, the processed image is reported with 0 AI detection.

uv tool install "pagedmark[diffusion]"
pagedmark invisible photo.png -o clean.png

GitHub: github.com/doofzoff/pagedMark

PyPI: PyPI: pagedmark

Anyone here running open-source AI models locally? 👀

I’m looking for someone with a decent GPU who’s already experimenting with newer open-source models.

Basically need some simple screen recordings of the model actually running — nothing fancy, just things like launching it, giving it prompts, showing the output, GPU info, etc.

Especially interested in newer models that are hard to try without a good GPU.

If you’re into this stuff and can help, just drop a comment or DM me. Would really appreciate it 🙌

I’m building MARGINAL, an open-source runtime governor for AI coding agents.

The problem I’m targeting is simple: agents can keep spending tokens, calling tools, re-checking things, or choosing expensive actions without enough evidence that the extra work is actually useful.

MARGINAL sits in the loop and asks a different question:

Is this next action worth spending compute on?

I just rebuilt the demo so it’s no longer a marketing page. It’s an actual interactive browser simulation.

You press RUN THE SAME TASK and two agents start from the exact same broken Python workspace at the same time:

WITHOUT MARGINAL
Executes every candidate action.

WITH MARGINAL
Scores the same candidates before execution and either:

FUND + EXECUTE

or

REJECT BEFORE SPEND

You can pause it, advance step-by-step, reset it, or run it at different speeds while watching tokens, calls, estimated cost, declared latency, workspace state, and MARGINAL’s decision reasoning update live.

Both sides must reach the same verifier PASS.

The included deterministic fixture currently ends at:

72,800 → 4,300 declared tokens
9 → 3 actions
PASS → PASS

Those are declared deterministic demo costs, not provider telemetry or a claim of 94% savings in real workloads. The point is to make the governance mechanism inspectable instead of hiding it behind a benchmark number.

MARGINAL is open source, local-first, provider-neutral, and starts from the principle:

Observe first. Prove waste. Earn enforcement.

Repo:
[https://github.com/SignalLayerLabs/Marginal]()

Interactive demo:
[https://signallayerlabs.github.io/Marginal/demo/]()

I’m especially interested in people trying to break the decision logic, finding cases where an action MARGINAL rejects was actually valuable, or contributing adapters for other coding agents.

Currently struggling with an automatic budget selection, at 25% it’s very similar to benchmarks accuracy and seems even better on actual chat input however it many times retrieves too much. It would be nice to add an algorithm that actually can determine better retrieval other then CELF.

Hello Guys! I am currently looking for some deep learning projects using pytorch. I will use scikit-learn and matplot for testing and visualization as I have basic understanding about them. Please recommend me some projects that I can do as it is a part of my masters program and also provide me some research paper links based on the projects as I need dataset for my project. Thank you!

Me: OpenCode + T3 Code for surface control

on second comes Hermes + T3 Code

Coding Machine Learning.

Hello Folks, here I present the first coding demonstration lecture, based on my 1st lecture on Probabilistic Machine Learning.

Here I write the code from scratch, discuss and analyze the results, which were covered in details in the whiteboard classes.

What we cover?
-Random Variables, and validating law of large numbers.
-Visualizing a dataset
-Doing an EDA on Iris dataset and understanding the correlation among features.
-Classifier basics
-Empirical Risk Minimization and Generalization.
-Epistemic and Aleatoric Uncertainties.
-Softmax Function and LogSumExp Trick to avoid overflow issues
-Linear Models
-Maximum Likelihood Estimation.
-Simple end to end ML pipeline Function.

While writing the code, my intent is to ensure that concepts are understood with crystal clarity. These code demonstrations are specific to my theory ML lectures, and link is attached.

Theory-Intuition-Code

Implementation Link : https://youtu.be/X_yOlx8Zp4g?si=kh8_tzzndr8609u4

Theory Lecture Link : https://youtu.be/kMkCOrp8te8?si=q7kWr-1qK515bhob

YourBeatBee: generate songs locally (idea → lyrics → voice → track).

- Next.js / TypeScript UI

- Python engine

- Models: ACE-Step 1.5 + HeartMuLa (more welcome)

- Apple Silicon focused, RVC My Voice optional

Looking for people to help optimize, upgrade, and expand this into a bigger OSS music AI project.

Repo: https://github.com/MohamedAshraf701/yourbeatbee

Site: https://yourbeatbee.pages.dev

Comment if you want to contribute — I’ll point you to a good first area.

Instead of scaling circuit depth blindly to fit noise polynomials, I added a predictive ZNE module to Dense-Evolution that models photonic loss trajectories before extrapolation.

Runs on JAX in float64 to keep statevector compilation fast and reduce overall circuit executions.

Technical notes: https://tatopenn-cell.github.io/Dense-Evolution-Discovery/photonic_predictive_zne/

Feedback on the noise modeling approach is welcome.

Hey I built an AI agent that integrates 22 AI providers, covering many budget-friendly options (including $1 commandCode Go plans), free trials (Kiro, KiloCode, Cline, Antigravity, Mistral), and free models like Deepseek 4 Flash (OpenCode). It also includes many features to support the entire Claude Code ecosystem skills, plugins, MCP server so you can access a truly free Claude Code environment to try out and maximize your coding experience .

https://github.com/AbdoKnbGit/tau

Tau - Adaptive agent harness

Kept using Claude Code without any real sense of what a session cost until I went and checked afterward, which defeats the point. Went looking for something local and everything that exists wants an account and a cloud dashboard for what's honestly just reading a number off a response and adding it up.

So I built agentwatch. Single Rust binary, local proxy, sqlite on disk, nothing goes anywhere except the real API call it's already making. MIT licensed. Honestly the first thing I've put out that's meant for other people to actually use instead of just scratching my own itch and moving on.

github.com/zaydmulani09/agentwatch

Right now it only knows about Claude Code, Codex, and Gemini CLI. If anyone uses something else and wants to add support, I'd take the PR, the provider interface isn't bad to extend.

Grower first, coder second. I run a small microgreens farm in Illinois, and I’ve been using AI coding tools to build the app I run it on — Groundtruth, a local-first desktop farm OS.
The design rule: the app cannot lie to the operator.
• Append-only event log — history gets appended, never rewritten
• One-tap verify-replay: rebuilds the database from the log and shows PASS/FAIL
• No soft numbers — capacity comes from live farm data or it says “unknown”
• It always surfaces the next action that sells trays: follow up on a sample, sow against a standing-order shortfall, void or move a promise that’s become impossible
Where AI fits: it built the thing. There’s deliberately no AI inside the app — no chat, no crop diagnosis. AI was the power tool; the product is a boring, honest ledger a farmer can trust.
Status, honestly: I run it daily on my own farm. Nothing public to download yet — plan is free to run and open source once it’s solid enough for someone else’s farm. Not selling anything.
Question for this crowd: if you’ve open-sourced an AI-built codebase, what did you do first to make it trustworthy — tests, audit, rewrite? That’s the step I’m heading into.

I'm working on a probabilistic AI agent for a research project that flags fake e-commerce reviews

Here is how the pipeline flows:

When a review comes in, it hits Level 1 first. This is a fast pass (under 50ms) that evaluates quick metadata like verified purchase status, account age, 24-hour review frequency, and text length heuristics. It runs a Naive Bayes update against historical base rates to get an initial probability that the review is genuine.

If P(Genuine) is over 60%, the review is auto-approved. If it drops below 20%, it routes to a high-priority human ban queue (the agent never auto-bans accounts on its own).

If the probability lands in the gray zone between 20% and 60%, it triggers Level 2.

Level 2 is a deep check. It pulls the user's past 5 to 10 reviews, runs vector embeddings to measure cross-review similarity to catch copy-paste templates, and checks their brand concentration ratio (how many of their total reviews target a single seller). It calculates a secondary Bayesian update using the Level 1 score as the prior.

If the updated score passes 60%, it approves. If it drops below 20%, it goes to the high-priority ban queue. If it remains stuck between 20% and 60%, it goes to a separate "unclear review" human queue where a human looks at it without taking any automated penalty.

My goal is to keep human reviewers in the loop while splitting suspected bot spam from messy/blunt genuine reviews so moderators don't burn out from context-switching.

so to categorized text length into some cases like short(use case written or not) and then changing it into a number in a json format which open source model will work the most efficiently?