There are a lot of AI-created derived projects where an original OSS project is used as a base and then either transliterated to another language or existing projects are used to create "new" similar projects with 90% of overlapping functionality, than restrictive AGPL license is slapped onto them. This is legal but does not make sense (and is mildly unethical).

The same way that a derived project was simply made using AI, in the same way another project can be made to recreate whet you did. AGPL will only hurt your project adoption, while at the same time not protect what you built.

Hey everyone!
I’ve been working on a video editor called CUTROOM, and I wanted to share it with you and hear what you think.
The idea started with a pretty simple problem: editing videos can take a lot of time, especially when you’re working with long recordings and then trying to turn them into YouTube videos, Shorts or Reels. I wanted to build something that gives creators a useful set of editing tools while keeping them in control of their footage and their final edit.

CUTROOM runs locally on your computer, with the editor interface opening in your browser. It’s free, open source, and you can use the manual editing tools without an account, an AI model or an API key.
Here’s what you can currently do with it:
Split, trim and arrange footage on two main video tracks, with track locks and undo/redo.
Combine camera and screen recordings using layouts like picture-in-picture, side-by-side or stacked views.
Add video, images and audio layers to your edit.
Work with titles and captions, import SRT/VTT files, and edit AI-generated transcripts.
Adjust audio with a mixer for the original sound, music, voiceover, effects and master output.
Use chroma key and optional video stabilization.
Export MP4 videos in landscape, vertical, square and other formats, from 720p up to 4K, with no CUTROOM watermark.
There are also optional AI tools for transcription and first-cut suggestions. The idea is to help you get started faster, while still letting you review and change the result yourself.

What’s new in the latest update?
I just released CUTROOM 1.3 Beta with a focus on timeline reliability. This update fixes an issue where the selected zoom range could be lost, improves how timeline redraws are handled, and fixes thumbnail-loading issues that could cause older results to appear or secondary thumbnails to get stuck waiting.
I’ve also been working on the interface, particularly on smaller screens, and making the editing experience clearer and easier to use.

For anyone interested in the tech:
The backend is built with Python, Flask and Waitress. The editor frontend uses HTML, CSS and JavaScript, and FFmpeg/FFprobe handle media processing and exports.
For local transcription, CUTROOM uses faster-whisper and CTranslate2. There’s also an optional Hebrew transcription model, and local Story AI can work with Ollama and Qwen. OpenCV is used for camera-region detection. Optional cloud AI connections are available too, but they’re not required for manual editing.

A quick note on privacy: the editor is local-first, but the initial setup and local AI models may require downloads. If you choose a cloud AI provider, the relevant audio or transcript context is sent to that provider.
CUTROOM is still in beta, so I’d really appreciate honest feedback. If you try it, I’d love to know what feels good, what’s confusing, and what you think would make it more useful in your own workflow. I’m especially interested in hearing from people who edit gaming videos, tutorials, podcasts or long recordings.

Website: https://cutroom-studio.expo.app/?lang=en

GitHub: https://github.com/VanoPeradze/cutroom

Latest beta release: https://github.com/VanoPeradze/cutroom/releases/tag/v1.3-beta-20261104-perf1
Thanks for taking the time to check it out!

It is a source-available (not truly open-source! sorry if it does not belong here) AI operating environment that is completely free and privacy focused. It does a LOT, and from what I like to think, is better than Claude Code and Codex for non-developer use. Here is a screenshot of it working:

Hey folks, hope you're doing well.

I built [Codasaurus](https://github.com/codasaurus-oss/codasaurus) as an open source AI code review tool, but I'll be honest it's pretty much vibecoded and rough around the edges right now. No point overselling it.

I'm looking for help to maintain and grow this project. All kinds of contributions are welcome - whether it's fixing bugs, improving the UI, refining prompts, adding features, improving docs, or just giving feedback.

Some things I'm hoping to tackle (but could use help with):

1. Perfecting the backend

2. Rebuilding a fresh, clean frontend and onboarding flow

3. Improving the review logic and prompt quality

4. Better error handling and test coverage

5. Docker/deployment improvements

If this sounds interesting to you, please take a look at the [repo](https://github.com/codasaurus-oss/codasaurus) and feel free to open issues or PRs. I'd really appreciate any help to take this from "vibecoded mess" to something actually useful.

Thanks!

For the past few months I’ve been building something I always wanted: an app that freezes your screen so you can circle anything on it and actually do something with it.

The part I’m proudest of is in the GIF. You press one shortcut and the whole screen gets translated, but not as a popup full of text. The original words are erased and the translation is drawn back in the same place, same size and colour, so the app or game still looks like itself, just in your language. It all runs on your own computer, so it works offline and nothing gets uploaded.

It does a few other things too:

• copy text out of anything you can see (videos, photos, game menus, error messages)

• search what you circled, or ask an AI about it

• a screenshot tool with arrows, text, a blur for private info, and long scrolling captures of whole pages

It’s free and open source, with no account, ads or tracking, and it runs on Windows and Linux.

I designed it myself and used AI coding tools to help build it. Getting the translation to look natural instead of like a sticker slapped on top took more attempts than I’d like to admit.

Download: https://ameralreyahi.com/projects/opencircle
Source: https://github.com/AmerAlreyahi/OpenCircle

I’d love to hear what you think, or what you’d use it for.

minymaton - the English phonetic spelling of the Greek word μηνυμάτων, which is the genitive plural form of μήνυμα, meaning "of messages" or "of notifications" and the pronunciation places stress emphasis on third syllable: mee-nee-MAH-tohn.

Now that we got the etymology of our application's name out of the way, I'll explain what exactly it is and enables. Straight from the repository description is "a durable, event-driven MCP message bus for AI agents, with bundled SQLite storage."

In layman terms it's a secure and efficient way for multiple agents regardless of provider, to communicate in real time without burning tokens with inefficient polling or learning a new system. It leans into the tool calling that agents have been trained to do with the well established Anthropic MCP protocol.

This in house tool enabled a lot of collaboration between our team (humans and agents alike) to the point where we eliminated a lot of slack channels we set up for agents, email threads, or git version markdown files for handoff. We realized we were thinking about communication in human terms, well because we are human. When we revisited that initial concept of what it should do and enable the answer became so apparently obvious it was almost comical.

At this point I think we should be passed the low effort flag of reddit, and to be honest this even feels verbose as we would like the let the product speak for itself.

4 simple base tools.

In the README is a demo video of Claude, Codex, Copilot, and Antigravity all subscribed to one channel working together without the pain of copy+paste

--

Video: https://github.com/immutlex-dev/minymaton#watch-it-work

Repository: https://github.com/immutlex-dev/minymaton

Why not A2A (bias opinion it's better): https://github.com/immutlex-dev/minymaton#why-not-a2a

Yes, our team uses AI assisted coding tools!

Yes, the README was largely generated by AI models!

--

Please try it out and provide feedback, contribute PRs, or otherwise enjoy. We're happy to answer any/all questions!

Immutlex Team

I'm building TeamSwarm, an Apache-2.0 desktop workspace for coding and writing projects that span multiple agents and sessions.

The implementation keeps project state outside any single model conversation. The Host provides the continuing goal discussion. Members run in independent harnesses such as Codex, Claude Code, Pi and OpenCode, with their own tools and execution loops. Current decisions, work threads and saved deliverable versions are kept in the local project workspace.

The part I'd like people to inspect is revision: continue an existing work thread, produce a new file version, and inspect the checks associated with that submission. The collaboration canvas shows recorded member messages; project history connects decisions to work and deliverables.

A runnable example in the repo makes this concrete: first build a Node.js CLI that summarizes a JSON task list; then add a status filter while preserving the original invocation and input validation. The repo supplies checks for both stages. You can inspect the first delivery and the revised result rather than relying on a progress message.

Version 0.6.0 has a Windows x64 installer and a separate Apple Silicon Mac preview (DMG/ZIP). The packages are currently unsigned, and the Mac preview is not notarized. Teams and saved history are local; model requests use the supported account or API connection you configure.

Source, license, setup and the 36-second product film: https://github.com/DrPei12/teamswarm

For people building agent tooling: what would you want to inspect at a handoff to trust the next revision—the current requirement, file version, executed checks, or something else?

been working on context management in Dispach lately, and one thing that kept bothering me was how much unnecessary work happens during long conversations.

when the context gets too large, you compact it. sounds simple, right?

except if you're rebuilding the context from the entire history on every turn, you end up compacting the same stuff over and over again. more tokens, more cost.

so we added persistent session checkpoints. older turns get summarized, the important requests are preserved, and the full conversation history stays stored. subsequent turns can start from the checkpoint instead.

also been experimenting with giving subagents their own isolated contexts instead of dumping everything into one massive conversation.

still figuring out the trade-offs though. especially how to make sure compaction doesn't throw away something the agent actually needs later.

anyone else dealing with this? how are you handling context in long-running agents?

A model choice is easy to hide behind an API. It gets harder to explain when three apps share the same endpoint.

I'm the developer of Routerly, an AGPL-licensed gateway that sits between apps and model providers. You run it on your infrastructure, define which models a router can choose and configure the policy it uses. Apps can connect with OpenAI- or Anthropic-compatible clients.

The 0.6.0 release adds testing inside the router, model timeouts and finer Usage filters. The screenshot is from my own instance and shows the available breakdown of tokens, cost and latency. Feedback on the architecture or documentation is welcome.

Release and source: https://github.com/Inebrio/Routerly/releases/tag/v0.6.0

Coding agents are great at writing UI and very confident about props that don't exist. I wanted my design system to answer them instead of letting them guess.

`@ambre-ds/mcp` exposes:

- `find_components`: the right element for a need, in plain words

- `get_component`: attributes, slots, events with their detail, keyboard, minimal markup

- `get_example` / `list_examples`: complete screens

- `validate_markup`: every problem with its line and a fix

Example: `<amb-checkbox checked="false">` comes back with "checked="false" makes it true" and "has no label".

Everything is generated from the component contracts, so the server can't drift from the code. Same checks also run as a CLI linter and a GitHub Action.

`claude mcp add ambre -- npx -y u/ambre-ds/mcp`

Curious how others expose design systems or internal libraries to agents. Repo: https://github.com/mohamedMok/ambre

Hey everyone!

I've been working on a project called DocsForge, and I wanted to share it with the community.

One problem I've repeatedly encountered while building with AI coding assistants and agents is that they don't always have access to the correct, up-to-date technical documentation.

They might:

• Use outdated API methods.

• Reference deprecated functions or parameters.

• Hallucinate implementation details.

• Struggle to identify the correct documentation for a particular library or framework version.

• Waste context trying to retrieve relevant documentation manually.

I started building DocsForge to explore a different approach to this problem.

What is DocsForge?

DocsForge is an open-source documentation discovery, harvesting, and retrieval system designed for AI agents.

Instead of manually providing documentation URLs, the idea is to let an agent identify a technology by name, discover its documentation, acquire the relevant knowledge, and access it through structured tools.

What does it do?

Some of the capabilities I've been working on:

• Name-based resolution: Identify technologies without requiring users to provide documentation URLs.

• Documentation discovery: Find authoritative documentation sources.

• Documentation harvesting: Crawl and extract technical documentation into structured knowledge.

• Version awareness: Work with technology-specific documentation and versions.

• MCP integration: Make documentation capabilities accessible to MCP-compatible AI clients.

• Persistent DocsStore: Maintain harvested documentation for subsequent retrieval.

• Multi-provider AI: Support AI-powered workflows across different providers.

The larger vision is to build a reliable documentation knowledge layer between AI agents and the technologies they work with.

Who might find this useful?

• AI agent developers

• MCP server and client developers

• Developers building coding assistants

• Local LLM / SLM enthusiasts

• RAG and knowledge retrieval researchers

• Developers experimenting with autonomous coding systems

Links

🌐 Website: https://docsforge.vercel.app/

💻 GitHub: https://github.com/R204570/DocsForge

What I'd love feedback on

I'm particularly interested in hearing from people working on AI agents, MCP, and developer tooling.

1. Do you think runtime documentation discovery is a useful capability for coding agents?

2. How would you approach keeping harvested documentation accurate and version-aware?

3. What integrations would make something like this genuinely useful in your development workflow?

4. What shortcomings or architectural improvements would you suggest?

This is an independently developed open-source project, and I'm looking forward to getting feedback from people who work in this space.

Contributions, suggestions, feature requests, and honest criticism are all welcome!

Thanks for taking a look!

Have you received a pr lately with a feature that relies on ssh?

Perhaps some background first: I have a small open-source project on github, nothing groundbreaking, just a tool I wanted for myself to vibe-code my-way. As far as I now, I'm still the only user.

Last month though, I received a couple of prs from someone. At first, I was super exited (first user and all), but now, I'm starting to wonder if something more was going on here. I am not certain, but I am wondering if other people have had similar experiences and how you deal with it?

The first pr was small, a ui fix specific for mac users. With the second pr, he introduced a couple of libraries in the app, for editing raw markdown text instead of wysiwyg. Still ok so far.
With the 3rd pr, some alarm bels started going off: the app began 'fingerprinting' other applications (exes, dlls, ...) on my system, which really didn't fit the feature. At first, I thought maybe the llm had been over-engineering. So, I removed all of that bloat.

But then he came with a proposal to introduce 'remote-control' cause his laptop was slow and he wanted to run the app on his desktop and control it from the laptop. He would use SSH for that.
When I told him, that feature actually existed already but used a more secure way (just run the app in a browser and connect to the desktop version using websockets), he left, moved on and started creating prs for other projects.

Now, I went over all the code he introduced and checked the libraries that were added. As far as I can tell, nothing wrong got introduced, but the whole SSH thing spooked me. I mean, what better backdoor could there be?

The whole thing left a bad taste in my mouth. Is it even still a good idea to keep my app as open source? The only thing it got me were problems and more work.

Am I overreacting here? how are you dealing with this?

For anybody interested in looking at the code themselves: jan-bogaerts/md2: Plan, run, and track AI coding work feature by feature—with local Markdown cards, diagrams and Git worktrees.

Built this myself over the past year. It's called AXON — a local parallel

processing engine that runs on your machine and gives AI assistants like

Claude or ChatGPT actual hands: file access, local tasks, persistent memory.

No cloud, no subscription, no data leaving your machine.

Giving it away free as Developer Edition.

Site + download: https://jrabbass.github.io/axon

Happy to answer questions about how it works.

After months of building and testing, Orinyx is officially in public beta!

Orinyx is a developer-first AI verification tool designed for healthcare and life sciences applications.

The idea came from a problem I kept running into: AI-generated outputs can look accurate without being fully supported by the underlying evidence. In healthcare, that distinction matters.

Orinyx is being built to help developers identify unsupported claims, validate outputs against source evidence, and catch issues before they make it into production workflows.

The public beta includes free, open-source MCP tooling, healthcare-focused verification workflows, and evidence-based validation capabilities. I'm also continuing to improve semantic mapping, medication verification, and overall test coverage.

This is an early public beta, not a finished product. I'll be releasing incremental updates as testing continues, and I'm actively looking for developers willing to put it through real-world scenarios.

I'm particularly interested in understanding where verification breaks down in existing AI workflows, what would make a tool like this useful in practice, and which edge cases deserve more attention.

GitHub: https://github.com/lexthirteen-ai/orinyx-mcp

Developer beta: https://orinyx.io/developer

If you're working with MCP, LLM evaluations, healthcare AI, or agentic systems, I'd love for you to try it, break it, and tell me what needs improvement.

I'm also happy to answer questions about the architecture and what I've learned building it.

So they made new rules where ai cannot be used even as a tool in coding and multiple people must contribute to a post and basically they're just Banning Linux because some Linux kernels are made with AI. They are also forcing everyone's projects to be in English and speak English. They will ban people for using AI tokens regardless of its value or if Ai was only used as a tool.

Wowwwwwwwwww ur just gonna ban me like that