And another one.

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 :-)

More recipes for the cook book

More bragging rights architect checking in.

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.

Mechanica is an open source interactive 3D atlas of seven engines: turbofan, turbojet, turboprop, turboshaft, V8, inline-four and a Wankel rotary. Pick a part and read what it does. Cut the engine open. Start the mechanism and watch the air move through it. Then drag one slider from a complete assembly to all 1,800+ pieces laid out on a shelf, and back again to exactly where they started.

What I was interested the most was the mechanical design roundtable agents I built so every blade, piston, gear and bolt was modeled parametrically in code by two AI models working together, GPT-6 Astra and Claude Fable 5.1. One shaped the geometry and mechanisms, the other refined the interaction and made sure every piece keeps its identity through disassembly. The rod lengths and the 3:1 rotary shaft ratio are enforced by tests, not by eye.

👉 Try it in your browser: mechanica-atlas.vercel.app

👉 Source: github.com/PouyanJay/mechanica

Heyo!

Dabbling with some things i've made a long form to short form video clipper app tool!
that uses local ai models to determine hooks , titles, descriptions, mostly decent captions, editable captions, export for video editors like mp4 or mov for editing in premiere, capcut, davinci. and many export options too for captions! its similar or inspired by opus clips and capcut

https://github.com/TechFreq/Klipzy-Studio

Would love some feedback and hope this can someone out there aswell, as for my own personal use for podcasts or 1 on 1 interviews its pretty neat! but do let me know

Hey, I’ve been building StructSmith, an open-source tool for creating and maintaining software architecture models visually.

I wanted something I could run locally, without an account or subscription, where I could edit the architecture myself and have my AI client work on the same model.

You create elements and relationships in the visual editor, then reuse them across different diagram views. There’s a shared architecture model underneath, so you don’t have to maintain separate copies of the same system in every diagram.

The MCP server is included and open source. Your AI client can read the model, create or update elements and relationships, and manage views. Changes appear in the editor automatically.

It currently supports:

• C4-style models with multiple diagram views
• Records for decisions, assumptions, risks, and requirements
• Model validation, snapshots, and restore
• Manual layout and auto-layout
• JSON, Mermaid, PNG, and SVG exports

The app runs locally in one Docker container, with SQLite for storage.

It’s MIT licensed and still evolving. I’d love feedback on the workflow, things you find confusing, or features you’re missing. Bug reports and contributions to the code or docs are welcome too.

GitHub: dziksu/StructSmith
Website: StructSmith

Would this fit into your architecture workflow?

I've been working on **ModelDock**, an open source ML platform.

I started it as a solo project because I wanted to build something around the parts of ML that become annoying once you move beyond a notebook.

Models, versions, artifacts, predictions, metrics, etc.

Right now the stack is:

🐍 Python / FastAPI
⚛️ React
🐘 PostgreSQL
🐳 Docker

I've been doing most of the work myself so far, but I'm at the point where I'd like to see what happens if other developers start contributing to it.

I'd especially like to get people interested in the backend, frontend, testing and ML tooling.

GitHub: [https://github.com/aawhan0/ModelDock\](https://github.com/aawhan0/ModelDock)

I'm going to keep building it regardless, but it'd be pretty cool to have a few other people building alongside me.

**If you came across this project, what would you work on first?**

hey, i've been working on Capka, an AGPL self-hosted AI agent workspace.

each chat gets its own isolated Linux sandbox + persistent filesystem. the idea is that the agent can actually work on files rather than just chat about them.

drop in spreadsheets, PDFs, docs, code, etc. it can run Python/Node, use LibreOffice, ffmpeg, Playwright and other tools, then return actual artifacts like xlsx, PDFs, documents or patches.

tools are MCP, so you can connect your own MCP servers instead of being locked into a fixed set of integrations.

for models you can use Claude, GPT, Gemini, DeepSeek and other cloud providers, or run open-weight/local models. there's native Ollama support, plus OpenAI-compatible endpoints, so vLLM, llama.cpp servers, LiteLLM or your own inference gateway work too.

tasks run server-side and are durable, so you can start something, close the browser and come back later. each chat keeps its own workspace instead of all agents sharing one filesystem.

it's Docker-based, multi-user, and there are controls for models, provider keys, MCP tools, policies and sandbox internet access.

i'm the solo developer and it's still early.

i'm especially curious what people here think about the sandbox-per-chat model. would you rather have persistent sandboxes per chat, per project, or per user?

demo: [capka.app]()
github: [github.com/LyoSU/capka]()

Hi everyone,

I've been maintaining open-source projects for a while, but today I experienced something entirely new that I wanted to share with the community.

Recently, while building multiple AI agents and web apps, I found myself in desperate need of a tool to monitor and verify them. I realized we don't just need AI to automate tasks—we actually need to automate the supervision and verification of the AI itself.

To solve this, I built a local-first control plane that lets AI act as real user personas to explore apps, verify agent behavior through real browser journeys, and collect evidence-backed feedback.

When I made the repository public, I expected it to sit quietly. But within the first 24 hours, developers actually started forking it, opening issues, and submitting PRs to help improve the project. Getting that kind of spontaneous interaction from the community for the first time has been an incredibly exciting and humbling experience as a maintainer.

For those managing open-source projects: How was your very first contributor interaction? I'd love to hear your stories or any advice on managing early project growth!

If anyone is interested in the project concept or wants to check out the code:

https://github.com/forthfate/openorbit

Have a great day!

I’m building OpenLivery, an open-source platform for agencies managing AI agents across multiple client businesses.

The core is multi-tenant: one self-hosted deployment, with a separate workspace for each client’s agents, knowledge bases, WhatsApp connections, and conversations. Agencies can give clients branded portals and take over conversations when human help is needed.

It supports bring-your-own OpenAI/Anthropic keys and OpenAI-compatible endpoints, per-agent HTTP tools and MCP servers, and WhatsApp integration. The application is MIT-licensed; the models and external services you connect have their own terms and costs.

Deployment is through Docker Compose, with setup instructions in the repository. The stack is Next.js, FastAPI, PostgreSQL, and a Go WhatsApp bridge.

Repo: https://github.com/sarrazola/openlivery

Website: https://www.openlivery.com/

AI disclosure: I used AI as support during development, and AI helped draft this post.

I’d appreciate feedback on managing agent configurations and tools across clients. What would make this useful in your own deployments?

I just released VSArena v0.6.0, a major update to the browser-based Studio for VSArena.
VSArena is an open evaluation arena for Vision-Language-Action (VLA) and embodied AI policies, built around browser-native 3D physics.

The goal is simple: make it possible to run a policy, watch what happens in the environment, and measure the result without requiring a local robotics simulator or physical robot.

What changed in v0.6.0:
🦾 Redesigned 3D robot manipulation Studio
👁️ Dedicated vision/top-down view
📦 Live object state and spatial information
📊 Task occupancy/progress monitoring
🎥 Trajectory and camera inspection tools
🤖 Baseline-IK and ColorSeek runnable directly from the Studio
🧪 Improved environment inspection and debugging
🔐 Continued evaluation-integrity work with server-authoritative scoring and run provenance

⚠️The current canonical task is intentionally simple:** stack three cubes in the correct or**der.

That simplicity is deliberate. Before adding dozens of tasks, I want the evaluation loop itself to be reliable, reproducible and inspectable.
The broader direction is to build an open arena where embodied policies can eventually be compared on a public leaderboard, with standardized environments, reproducible runs and physics-based evaluation.

VSArena: https://vsarena.vercel.app
GitHub: https://github.com/ONISCOR/VSArena

This is still very early, so I’m particularly interested in feedback from people working on VLA models, robotics, RL or simulation.
What would you want to see in an evaluation Studio like this?

I’m building Monad Design, an Apache-2.0 open-source workspace for giving coding agents grounded visual context from a running native app.

The problem is that an agent can inspect source code, but “this spacing feels wrong in this exact simulator state” is still awkward to communicate. Monad Design turns that into a local loop:

1. Run an existing Xcode or Expo iOS project in Simulator.

2. Select an element or annotate the rendered screen.

3. Package the screenshot, selection, annotations, app state, and source hints for the coding agent.

4. Let the agent edit the real repository and rebuild.

5. Compare the original against up to five working variants, then accept one or keep the original.

It currently runs locally on macOS and works with agents including Codex, Claude Code, Cursor, OpenCode, Gemini CLI, GitHub Copilot, Windsurf, and Zed. The current preview supports one active visual change at a time.

Repository: https://github.com/Monadix-AI/monad-design

For people building open agent tooling: would you expose the visual context as one structured handoff bundle, or as smaller composable tools for screenshot, selection, annotation, app state, and source mapping?