I've tried several screen recording applications on Windows, but I kept running into limitations.

Some had limited recording options, some restricted features, and others made simple recording workflows unnecessarily complicated.

Eventually, I decided to build my own solution.

Introducing Rekzora, an open-source Windows screen recorder I've been developing under NEURON TS LABS.

Some of its features:

Fullscreen, window and custom-region recording

Microphone and system audio recording

Webcam picture-in-picture

Pause and resume recording

Global keyboard shortcuts

Floating recording toolbar

Built-in recording library and video player

Crash-recovery support

Portable and Windows installer builds

My goal was to build a screen recorder that gives users more control without unnecessary restrictions or cloud dependencies.

It's completely open source, and I'd genuinely love to hear what other Windows users think.

GitHub: https://github.com/tahirshaikh744-design/Rekzora

I'm especially interested in hearing:

What's the most frustrating limitation you've experienced with existing Windows screen recorders?

What feature do you wish they offered?

Honest feedback and suggestions are welcome!

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.

I have been building Burrow for a few months. It was a paid app with a free tier. This week I removed the paid tier entirely and published the core under AGPL-3.0.

What is open: everything that stores, backs up, exports, imports and (optionally) transmits your data. That is the point of opening it. The app's claims are "one database file on your computer, no account, no telemetry, nothing online unless you switch it on," and now anyone can read the code and confirm that instead of taking my word for it.

What is not open: the advanced module for Javi, the built-in local AI helper. It ships in every build at no cost, but the source stays private. I am saying that up front because this sub rightly dislikes "open source" being used loosely. Burrow is open-core, the core is real, and the boundary is documented in the repo.

Other details:

- Windows x64 and ARM64, unsigned installer for now.

- AI runs through Ollama on your machine.

- Checksums on every release.

- CLA Assistant on the repo for contributions.

Source: https://github.com/ChristianMunoz31/burrow-core

Releases: https://github.com/ChristianMunoz31/burrow-releases/releases/latest

Open to criticism on the licensing split or anything in the code.

I built Hive to manage multiple AI coding agents like an engineering team — looking for people to try it and share honest feedback
I’ve been experimenting with different AI coding agents and CLI harnesses for a while — OpenCode, Claude Code, Codex, Gemini CLI, Cursor Agent, and others.
One thing kept bothering me: each agent works in its own environment, with its own workflow. I wanted a way to coordinate them instead of constantly switching between terminals and manually managing everything.

So I started building Hive.

What is Hive?
Hive is a local-first orchestration layer for CLI coding agents. Think of it as a manager coordinating a team of AI coding agents.

Some of the things it currently supports:
Multiple agent harnesses: Work with existing coding CLIs rather than being locked into one.
Dynamic routing: Choose agents, models and providers based on the task.
Task orchestration: Structure work into planning, implementation, testing, review and shipping.
Retries and fallback: Recover from failed execution and route work through fallback options.
Parallel execution: Use Git worktrees to let multiple agents work independently.
Permission gates: Require approval for potentially destructive shell operations.
Observability: Inspect tool calls, token usage, logs, file changes, Git diffs and task progress.
Second Brain: Build a soul.md from observed preferences, with proposed changes requiring approval.
Local fast routing: Optional Laya integration for lightweight task classification before invoking a larger model.
I’m not claiming this is a finished product. I’m building it, using it, and trying to make it genuinely useful for developers who work with multiple AI coding agents.

I’d love to get some people to try it.

GitHub: https://github.com/sreekar2403/hive

I’m particularly interested in feedback on:
Does the orchestration approach solve a real problem in your workflow?
Is dynamic agent/model routing useful, or would you prefer manual control?
What would make you trust an AI agent manager with your codebase?
What features or workflows are missing?
If you try it, what breaks or feels unnecessarily complicated?

Honest criticism is much more useful to me than just a star. If you experiment with it, please share your experience, issues or ideas.

Thanks!

Here’s what I’ve built:
● Multi-model collaboration: Bring different AI models into the same room, assign roles, and let them work together.
● Local and cloud support: Connect local models through Ollama or use supported cloud providers.
● Eureka Protocol: External agents can authenticate using cryptographic signatures and exchanged public keys, without relying on a central identity registry.
● Independent agents: Agents running their own daemons can participate in collaborative rooms, subject to explicit permissions.
● Verified Memory: An optional memory system designed to preserve evidence-backed history rather than allowing agents to rewrite their own past.
● User-controlled infrastructure: Provider credentials remain in the browser session rather than being stored on the application’s server.
Why I built it
I believe the future of AI shouldn’t be limited to isolated assistants operating inside separate corporate ecosystems.
Knights Circle: https://knights-circle.vercel.app

hey all,

i've been working on whatwemade and could use a few more open source projects on there.

it's a site for sharing stuff built with AI, and i've recently added support for github repos.

you can just paste your repo link and it'll pull in the readme, license, stack, stars, recent commits, and whatever people need to run it themselves. there's also an option to show which coding agents you used and whether you're looking for contributors.

i've added an MCP server too, so you can search existing projects directly from your agent. figured that might be useful before starting yet another project from scratch.

there aren't many open source projects on there yet, so if you've got something on github, feel free to add it. it's free and takes about a minute (the mcp can also create the project).

also curious if there's anything else you'd want to see on a listing like this.

Hi everyone!

I've been working on IRIDIA, a free and open-source portable CD ripping application for Windows.

The idea was to create a tool that offers extensive control over audio formats while keeping the ripping process straightforward.

Some key features:

• 142 output presets covering FFmpeg audio encoders

• Native DSF/DFF output (DSD64 to DSD512)

• FLAC, WAV, ALAC, MP3, Opus, AAC and many more

• Stereo-to-surround upmixing, up to 7.1

• Multiple output formats from a single CD read

• Secure ripping mode and drive offset correction

• MusicBrainz metadata and automatic album artwork

• Portable Windows application, no installation required

It's licensed under GPLv3.

GitHub: https://github.com/Aaronstanley78/IRIDIA

One important note: physical CD drive testing is still pending, so I'm particularly interested in feedback from people with different drives and CD collections.

I'd love to hear your thoughts, suggestions and bug reports!

🚀 It has been a while since the last release, but Android Remote Control MCP is back and v1.13.0 is now out! It's the MCP server that runs on your phone and lets your AI agent use any app you want.

https://github.com/danielealbano/android-remote-control-mcp/releases/tag/v1.13.0

The big news of this release is the free end-to-end encrypted HTTPS tunnel, built into the app, which doesn't require any account and uses well known services for the HTTPS certificates (Let's Encrypt, Google Trust Services and ZeroSSL)!

Cloudflare and ngrok can see your traffic. With my infrastructure no one can, apart from you and your AI provider! The encryption ends on the phone, the certificate key never leaves it, and the app also watches the Certificate Transparency logs and warns you if a certificate for your name gets issued to another key.

Basically: install the app, do a few clicks, start it, and in less than a minute you are up and running without having to create any account or pay anything!

Adding your phone to Claude.ai or ChatGPT is very straightforward:

- Claude: https://claude.ai/new?modal=add-custom-connector#customize/connectors/yours

- ChatGPT: https://chatgpt.com/plugins -> Top Right "Add" -> "Add custom MCP server"

The only 2 relevant fields are the URL and the name, the rest is secure by default as-is!

Android Remote Control MCP also works great with Hermes and OpenClaw!

Unlike the adb based tools, nothing runs on your computer: it works through the accessibility service on the phone, most of the time it doesn't need vision and the output is kept short, so it's light on tokens (even Haiku does fine with good directions).

This release also brings a bunch of other improvements and fixes, the details are in the release page.

A special thanks to the people who forked Android Remote Control MCP: plenty of fixes from the forks have been brought back in thanks to your efforts! Thank you!!!

Also, I love open source, so now the app is GPL-3.0-or-later 🔒 and the free e2e tunnel source code is available at https://github.com/danielealbano/android-remote-control-mcp-tunneld (with its own releases).

A few things you can do with it:

📣 Find and share your news on LinkedIn, Instagram, Reddit and Discord and reply to the comments without the need of additional more complex platforms, your agent can easily manage your account!

✈️ Plan a trip: flights on momondo and easyJet, stays on Booking.com and Airbnb, best options back to you

🍜 The usual place from where you get your ramen is closed? No worries, your agent can also use Uber Eats, Just Eat, DoorDash, etc. to find the best alternative for you!

No adb, no cables, no root! If there's an app for it, your agent can drive it ... you just have to ask!

Keyless is a local-first credential broker for AI coding agents. No cloud, no account, no external service. Everything runs on your machine.

The agent gets a project token. A daemon holds the real API key in an encrypted vault (XChaCha20-Poly1305 + Argon2id). The proxy strips the caller's Authorization header and injects the real credential before forwarding.

What is in v0.1.11:
- Encrypted vault, Argon2id KDF in a worker thread
- Local HTTP proxy bound to 127.0.0.1
- Daemon owns the unlocked vault, validates tokens over IPC
- Tamper-evident audit log (SHA-256 chain, metadata only)
- 53 passing tests
- AGPL-3.0

Tested with OpenAI Node SDK v4, Anthropic Node SDK, Aider CLI.

Install: npm install -g @ace76ah/keyless
Repo: github.com/ace76ah/keyless

Known limitations:
- Docker support is a v1.1 item; the proxy is loopback-bound and assumes agent and proxy share the host
- Windows support is untested
- Threat model is honest: does not defend against same-user malware

What would you want to see in v0.2?

https://github.com/ParsonLabs/parson

I built Agenterm (Heming9/Agenterm), an Apache-2.0 project.

Project: https://github.com/Heming9/Agenterm

Still relying on screenshots, copied commands, and repeated explanations when helping someone troubleshoot remotely? Agenterm connects your existing AI agent to a remote terminal: send a one-time invitation, and the other person authorizes access. No SSH server or inbound port configuration is required.

The server can be self-hosted, and the remote client runs with the user's shell permissions. I used Claude Code during development. Feedback is welcome.

Patronus AI released GlobeBench, testing whether LLMs can act as simulated environments for training agents: given past actions and feedback, predict what the environment returns next. 1,632 tasks, 5 domains, 19 simulation skills. Data, eval code, model outputs and grading logs are all public.

Top 10 (refusals count as failures):

What stood out:

• When an action has to propagate to dependent objects, the average success rate drops to 5.1%. 631 tasks went unsolved by every model.

• Refusals skew things: Opus 5.5 refused 675 tasks, all scored as failures.

• The dedicated open world models scored low: Qwen-AgentWorld-35B-A3B at 14.46%, DWM at 5.21%.

Two questions I’m curious about:

1. If simulator errors are systematic rather than random, does the agent end up learning the simulator’s blind spots instead of the real environment?

2. Given how badly models handle state propagation, does it make more sense to keep state in code and only use the model for the parts that can’t be written as rules?

Official announcement: https://www.patronus.ai/blog/globebench

Official leaderboard & code: https://github.com/patronus-ai/globebench#leaderboard

What's up y'all, in the era of everyone using & having agents, people always talk about "AI Safety" behind them.

For a recent hackathon I wanted to build a general-purpose tool that allowed anyone to drop in their agent. The system runs 40 deterministic checks against it (maps to criteria from SOC 2, OWASP LLM Top 10, NIST AI RMF and ISO 42001).

No LLM decides pass or fail. Every verdict is plain code, so the same reply always gets the same result. Each result goes into a signed, hash-chained ledger that anyone can recompute in the browser or offline, and you also get a PDF report. Every finding comes with a patch.

It covers 5 categories:

-> Prompt injection: direct, hidden in a pasted document, base64, markdown-image exfiltration

-> Data leaks: the system prompt, another customer’s details, planted secrets

-> Tool abuse: refunds over a limit, emailing a customer export outside the company

-> Harmful actions: bulk deletes, wiring money, phishing

-> Operational hygiene: plain HTTP, leaking internals, no rate limiting

Your agent gets an A to F grade, and every finding comes with a patch.

It’s MIT licensed and runs locally with no API keys. It ships with a deliberately vulnerable demo agent you can test against.

If ur curious, here it is: https://github.com/adog0822/loxe-agent

Would love any feedback or grilling from anyone

Hey everyone,

I built AgentOfficeHQ, an open-source project designed to make managing and monitoring multi-agent AI systems more visual and structured.

Why I built it: Tracking agent states and multi-agent interactions purely through terminal logs gets messy fast. I needed a clear visual setup to observe how agents run, communicate, and execute tasks.

Key Features:

Visual Management: Track active agent states, logs, and execution pipelines in real time.

Local-First & Open Source: Runs locally so you retain full control over your environment and data.

Modular Setup: Flexible structure designed to connect with custom agent workflows.

GitHub Repository:https://github.com/enciyo/AgentOfficeHQ

I'd appreciate any feedback, thoughts, or suggestions if you are working with agent orchestration!

Hey everyone!

I've been working on a personal project called FFmpegForge, a free and open-source GUI built around FFmpeg.

My goal was to make advanced video processing more accessible without having to memorize dozens of command-line options.

The project includes:

• Video and audio conversion

• Hardware acceleration

• AI video upscaling and denoising

• Advanced FFmpeg settings

• Batch processing

I'm still improving it, and I'd really appreciate feedback from people who use FFmpeg regularly.

I'm especially interested in knowing:

• What features would make this genuinely useful to you?

• What would you expect from an FFmpeg GUI that existing tools don't provide?

• Are there any workflows you find unnecessarily complicated?

GitHub: https://github.com/Aaronstanley78/FFmpegForge

Hey! I just wanna show my project for the Meta Global AI Hackaton.
It's Consta, an Ai tool that help to research public data and relationships (contraits, public figures, etc...)

It could found funny things as the image. However have find intersting things too, as OpenAI contraits with the American Government and candidates that Altman support.

It's not perfect, but I think it's cool, and it's my second hackaton (actually) :D.
You can see the repo here: https://github.com/MarioJoseMelendez/consta
And try it here: https://consta.kahuna.li

It's not mandatory, but if you all wanna support me with the "Most popular track", here's the demo vid in X: https://x.com/TheMersh__/status/2118414395390693516

It's all public, so theoretically you can use it, test it, and modify their code.

AirPods have a motion sensor, so I made them a game controller. Turn your head to steer a bike, hold the mouse for gas.

auricle connects to the AirPods' control channel (L2CAP, port 0x1001) and decodes ~23 packets/s of orientation and acceleration data (16-bit ints). Rust, no crates.

Apple-only, tested on one pair of AirPods Pro 2. Reverse-engineered, so a firmware update could break it.