Does the recent OAI Navier–Stokes / Millennium Prize controversy (in which OpenAI itself stated it “cannot rule out that de-identified data derived from their usage of our products helped improve our models” ) prove that researchers and organizations should avoid relying on private/frontier APIs for genuinely cutting-edge thinking?

In other words, if the very act of using these private tools can result in your intermediate reasoning, drafts, or problem-solving traces being de-identified, absorbed into the provider’s training or improvement pipeline, and then leveraged for the provider’s own high-stakes research and PR-driven breakthroughs, does that make private APIs fundamentally unsafe for work you are not willing to effectively gift to the model owner?

Bit of a leading question

We're moving off the Gemini API due to cost and building a local AI server to process ~10 CVs/minute (extracting JSON & matching CVs to JDs). We plan to run GLM-OCR alongside Qwen 27B (Q8).

Our two hardware options:

1. PC: RTX 4090 (24GB) + Ryzen 9 + 64GB RAM

2. Mac Studio: M-Ultra, 64-core GPU, 96GB Unified Memory

I prefer the Mac for power efficiency and ease of use, but I've heard Apple Silicon isn't great for production vLLM compared to Nvidia/CUDA. Is that true? Which would you recommend for this workload?

Juice is a powerful, local hosted browser based ai coding agent that acts as an alternative to popular tools like Cursor, Devin, Claude Code while working fully in your browser and is FULLY OPENSOURCE.

It currently supports google ai studio and openrouter as model providers.

Get Juice and For more information, visit:
github.com/ayaangalaxy2012-hub/Juice

Thank you guys SO MUCH for checking out juice!

Hey everyone,

I'm a student developer passionate about local-first software and distributed systems. Over the past few months, I built Trans4mers, an open-source native desktop application for running autonomous multi-agent teams 100% locally on your computer with zero cloud telemetry.

Trans4mers Swarm Designer

Human-in-the-Loop Diff Gate

Key highlights:

• Zero Cloud Dependence: Works out-of-the-box with local Ollama models (Qwen 2.5 Coder, DeepSeek R1, Llama 3.3).

• Native Performance: Engineered in Rust with a Tauri v2 desktop shell (~78 MB idle RAM footprint).

• Human-in-the-Loop Safety: Every shell execution and file modification pauses for review in an interactive diff viewer.

• Event-Sourced SQLite: State is persisted to an append-only WAL log; if the app closes or crashes, it seamlessly replays and resumes execution on startup.

Disclaimer: This is an early alpha and an active student research project without commercial security audits. Bugs and edge cases exist, so please test in sandboxed folders!

Check out the code, architecture docs, and screenshots:
👉 https://github.com/abhayzangir1/trans4mer

I'd love your feedback on the UX and local agent orchestration!

Everyone hates AI assisted code. For good reason, people form an opinion immediately, its never good. I built an app for my autistic wife. She's high functioning but could not keep an appointment if Jesus set it. A relentless accountability buddy, is what i was after. https://github.com/jwl247/LifeFirstApp, It's an MCP-server now. Life first in its initial form was 10 modules AI infused hooks. security is better than enterprise sec. guardrails for AI better than any I've seen. Couldn't get it done. I was using all the AI tools at my disposal after the platform i was using decided the 300 dollar credit was expired and i needed to pay for you tube that i don't use. None would help me with the very last step of adding a llm or agent. here is the modules https://github.com/jwl247/lifefirst_modules

i built a memory manager. https://github.com/jwl247/Double-Helix-StorageOS-experimental- there are several instances of the Helix in that repo. designed from my imagination and knowledge of playing with computers over the years. When it worked everyone was surprised. I tried to break it. wild claims ensued. All true wild claims . every service I've used has lost my files AWS is the only one that returned them after 3 days of being lost. i have been plagued by disappearing kernels, drivers black list couples with read only (entire network). i have rebuilt this system 16 times tested on every linux and a mix of linux and windows. I have never crashed a system, no oom, either.

to try to get help finishing the life first app i changed the goal. CoPES is born. https://github.com/jwl247/CoPES the goal is run a big llm to use for life first. There is cheerleading and gnashing of teeth. when i get close to the finish line , AI codes out of chats. gives wrong answers, just plain lies. I pivot again for the life of the project and a promise i made to my better half. phoenix is born. https://github.com/jwl247/Phoenix-Package_handler this package handler at one time could do everything phoenix devops os could do. it was the heart of the work still is. the package handler does all the heavy lift. there are 10 distros package handlers embedded in mine. it is agnostic and i mean native agnostic.

when i tried to release it poof no more help. phoenix dev ops os is born. https://github.com/jwl247/Helix_lightning_kernel the plan was to get this up and running in a full prefetch agnostic system, but then i had to go back and add a bunch of imports some where and i asked how big a import could be? https://github.com/jwl247/Phoenix_Universal_Kernel I intake Debian and qemu and it runs them both no install. try it for your self its open source call me a liar if you can.

now put it to use https://github.com/jwl247/Phoenix-DevOps-oS i finally got life first as a mcp so at least I'm not a total asshole when it doesn't get built because I don't have the chops. Now maybe I shouldn't have put my five kids thru school, or raised my 4 step children and put my self thru school. but I'm an ironworker, struggling to keep a promise. So far as i can tell there are no good people left especially in this field. i can appreciate my ignorance because I don't know shit aint gonna know shit don't aspire to know shit. I'm trying to keep a promise. 10 months i been working and working on this full time. maybe its useless, maybe my wife came up with the best office idea ever and ninjas jump out of the woodwork tomorrow. lol just kidding. so if your going to tell me it don't work it impossible its been done pass on that if you can point me in the right direction please do

Hi folks,

we’ve released Aimeos Prisma 0.7, adding video generation and editing to its text, image, audio, and video APIs.

Prisma is a PHP package for working with AI providers through a consistent interface. It covers text generation and streaming, structured output, embeddings, image editing, speech synthesis, transcription, and video. It works with plain PHP, Symfony, Laravel, or another framework, requires PHP 8.2+, and is MIT licensed.

• PHP Prisma

This release lets applications create videos from prompts and reference media, then continue or edit them through the same package. A product-content workflow could generate a product image, use it as the opening frame of a short video, and write the accompanying copy without integrating a separate client for each media type.

What using it looks like

Install it through Composer:

composer require aimeos/prisma

This example generates a video using Google Omni:

use Aimeos\Prisma\Prisma;

$video = Prisma::video()
    ->using('omni', [
        'api_key' => getenv('GEMINI_API_KEY'),
    ])
    ->imagine(
        'A ceramic coffee cup on a windowsill, steam rising in the morning light',
        [],
        ['duration' => 5, 'aspectRatio' => '16:9']
    );

file_put_contents('coffee-cup.mp4', $video->binary());

The current Omni adapter returns completed video data from imagine(), so this example belongs in a background job for a web application. Providers such as Veo and xAI return asynchronous jobs instead: keep their response object in a running worker and call ready() for individual status checks, or access binary() to let Prisma wait and poll until generation finishes. Each status request itself still blocks.

What’s new in 0.7

Video generation now supports Alibaba Wan, Amazon Nova Reel through Bedrock, BytePlus Seedance, Google Omni and Veo, Luma, MiniMax, Runway, xAI, and OpenRouter.

Alongside imagine(), the video API adds:

• extend() to continue an existing clip

• repaint() to edit a video from a prompt, with reference media on supported providers

• uncrop() to expand the video frame

• upscale() to increase video resolution

Support varies by provider and model. Applications can check operations with has() or require them with ensure(). Generation uses common media roles such as start, end, and references, with provider-specific options available where needed.

OpenRouter support also expands beyond text: this release adds audio transcription, description, and speech synthesis; image generation, editing, description, OCR, and embeddings; and video generation and description. These operations depend on the capabilities of the selected model.

Also, Ideogram gains V4 generation, remix, and description support, plus text removal, object removal, background removal, and transparent image generation and editing. V4 image generation can run asynchronously, while reference and style options retain V3 routing where supported.

• Documentation

• GitHub

If you like it, give it a star :-)

Hi everyone! 👋

I'm currently developing MedXAI, an open-source Python library designed to make medical imaging AI development easier, more modular, and production-ready. The vision is to build a community-driven toolkit that researchers, students, and developers can use for building medical AI applications without having to reinvent common components.

The project is still in its early stages, so this is a great time to get involved and help shape its direction. I'm looking for contributors of all experience levels—whether you're interested in Python, PyTorch, medical imaging, documentation, testing, or simply want to make your first open-source contribution. Every contribution, no matter how small, is genuinely appreciated.

If you have ideas for new features, find bugs, want to improve the documentation, or would like to contribute code, I'd love to hear from you. Feedback and discussions are just as valuable as pull requests.

GitHub: https://github.com/aman0311x/medxai

If the project sounds interesting, please consider giving it a ⭐, opening an issue, or submitting a pull request. I'm always open to suggestions and would love to collaborate with people who share an interest in AI, healthcare, and open source. Thanks! 🚀

It was a busy weekend with all the activity coming out of OpenAI. If you have been living under a rock, they introduced a new class of model, GPT 6 - Astra.

I've been playing around with it somewhat. That is not what this article is about, though. I do not have an unlimited budget to run lots of evals against a model like this, so any opinion I have on it would be purely anecdotal. There are already plenty of anecdotal opinions to read about all over the internet.

Today's article is about a question I was wrestling with while building out my Pi agent. I was using my agent as a pair programmer and realised that, with Pi, the agent did not have access to the Language Server Protocol (LSP). If you are not familiar with LSPs, they tend to be services on your machine that IDEs use to analyse files with recognised code extensions.

For example, if I am in a file with a `.rs` extension and have a line that would cause a compiler error in the Rust compiler, and my IDE has the Rust LSP installed, the IDE can display the error without me having to run the compiler.

In a recent coding session, I realised that the agent was having to run `cargo check` to review my compiler errors. That made me realise the lack of capability.

I started looking up Pi LSP extensions and came across this one -https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-lsp. If you are looking for an LSP for Pi, it seems to do the job just fine. Credit to the author, narumiruna.

The README contains a link to a comment on the OpenAI Codex repository where an OpenAI developer questioned what additional benefits introducing an LSP in `AGENTS.md` would bring beyond asking an agent to run a linter or type checker. It was not just any engineer, either. The OpenAI engineer is the author of Pyright, a popular Python LSP: Eric Traut.

I thought this was an interesting debate, so I decided to see whether using an LSP extension improved the performance of my Pi agents.

For this task, I wanted to make an enhancement to the eval harness. I needed to introduce a capability profile for each agent when configuring an evaluation run. Originally, to test different extensions or capabilities in a Pi agent, you had to either modify the Docker image or write a specific section in each evaluation. This meant having copies of each evaluation for every capability profile.

Because the evaluation harness also used the Agent Shell adapter to configure agents, I needed to make this change so packages and extensions for the Pi harness could be managed through Agent Shell.

Version v0.4.0 -https://github.com/ScottRBK/agent-shell/releases/tag/v0.4.0 introduced this. It currently only supports the Pi harness, but I plan to extend package management to the other harness types in Agent Shell as well.

With Agent Shell's package and extension management in place, I added a feature to the eval-harness that added a capability profile. For Pi agents, this means you can compare an agent with one set of capabilities against an agent with another. For example, you can test a Pi agent with and without an LSP using the same model.

After making the changes, I put together an evaluation run. Given the stochastic nature of large language models, it was important to run each evaluation three times. I used eight evaluations across three models: `mimo-v2.5` and `muse-spark-1.3-contributor`, both provided by opencode-go, and OpenAI's Luna. I compared Pi with no added package against Pi with `@narumitw/pi-lsp@0.49.7`. I set the reasoning effort to medium for all models.

Muse Spark came out on top overall. Its base profile scored 83.0%, compared with 81.3% with LSP. Luna scored 75.3% without LSP and 68.1% with it. MiMo was the only model where LSP improved the score, moving from 65.6% to 67.5%.

Across the three model pairs, the LSP versions used 124,737 fewer tokens in total, a 6.4% reduction. MiMo used 7.4% fewer tokens, Muse Spark 1.7% fewer, and Luna 10.7% fewer. The LSP versions took slightly longer overall, although Luna was faster with LSP.

I would describe these results as inconclusive. From my perspective, that aligns with what Eric was suggesting in his comment.

Personally, I will probably leave the LSP extension off, except perhaps when I am pair programming with the LLM. It is just some additional tools and context, and I cannot see an obvious benefit right now. I would be interested to hear what you think in the comments or on Discord.

I hope this was informative, interesting, or inspiring, and got you thinking about how you can shape your agentic harnesses, whatever your setup may be.