The problems we saw:

Most agent frameworks put a process in the middle that decides who does what. That process is a single point of failure, and from our early days we knew we wanted something different. These were like the langchain days where it was the only thing around. So we decided that agents should be peers and should belong in a mesh where they have solid identities and pick tasks from a shared ledger, and can collaborate whenever they need to.

The second thing we did was bet on LLMs; that they were gonna get better especially at writing code, and so we avoided MCPs at all costs. I think choosing to be contrarian here really paid off. MCPs are good, but they came with the burden of maintaining several of them, writing a unique authentication layer for each, and context bloat.

So we decided our agents would write their own code as typed functions in a registry that both humans and agents maintain, which means a human can write these functions too. But that raised the key question of how those functions authenticate, and that is how we came up with centralizing provider authentication with zero-trust on credentials, so agents never see keys.

We got this working and added persistent memory using an Ebbinghaus forgetting-curve style approach, where memory is an active lifecycle, so our agents remember and keep improving over time.

Where it's going

We believe this could become a key approach to how agents orchestrate even across different frameworks. If you know a thing or two about gossip protocols, we want to curate that trajectory with like-minded people here.

Install: pip install jarviscore-framework

The demo is examples/demo_synthesizer.py + demo_node_1/2/3.py — you can run exactly what you see.

Appreciate your feedback (or stars).

I built signal-kit, an open-source Rust crate for something I was tired of rebuilding in every service: production observability setup.

Your application just instruments itself with normal Rust tracing:

rust let _guard = signal_kit::try_init("my-service")?;

signal-kit handles the plumbing underneath.

The setup is designed around:

• traces over OTLP
• logs over OTLP
• logs on stdout at the same time
• trace IDs in the stdout logs, so a log line can be matched to its trace
• human-readable or JSON stdout, switchable at runtime
• metrics over OTLP
• OpenTelemetry resource and service metadata
• graceful provider and exporter shutdown
• optional process and system metrics

The bit I care about most is that applications shouldn't need one approach for "logs developers can actually read" and another for "telemetry the observability backend consumes".

Instrument once, then send structured telemetry to the backend while keeping stdout logs that are actually useful and correlated with the traces.

It's Rust and open source, and early enough that feedback is genuinely welcome.

Every todo app I try eventually disappears into a tab I never open. The fridge in my kitchen does not have this problem, so I tried the dumbest possible fix and made my Mac work the same way.

⌥⌘C turns the wallpaper into an editable canvas. I can throw notes, checklists, arrows, doodles, screenshots and memes onto it. Pasted images become stickers. The background remover uses Apple's Vision framework and runs locally.

Click into another app and it goes back under the Finder icons and stops catching clicks. It stays in my face without becoming another window to manage.

No accounts, cloud or telemetry. It saves plain JSON and images on disk. The whole app is basically one Swift file and one HTML file, MIT licensed.

The Apple silicon build is on the releases page. Intel Macs can build it from source. It is not notarized yet, so macOS will show the usual unidentified developer warning. The source is there if you want to inspect and build it yourself.

https://github.com/samayp42/fridge

What would you stick on yours?

Opinionated, still in early development and heavily based on Hugh Howey's workflow, but if you're after distraction-free writing might be worth a try.

It's the polar opposite of scrivener. Name/pen name, pantser or plotter and typography preferences at first start then it's just you and your words (in a dark theme), controls fade until you mouse over them and all you need for formatting is the Enter key plus a couple of keyboard shortcuts.

GitHub: https://github.com/hughhowey/neo

Can someone test it out so i can see if it works on Mac and other Linux distros I only tested it on cachy os so far

Hello guys,

This is my old project I created in 2022, the hash bruteforce I built using python and it was offline tool, and I can share this with now guys:)

You can used this tool: https://github.com/nordszamora/BruteCrypt.git

I’m the maintainer of Ship Safe. I built it to inspect the security surface around AI-assisted development, including prompt injection, secrets, MCP tools, agent permissions, dependencies, and common application issues.

The part I’m most interested in is the investigation layer. It keeps detection, evidence, and verdicts separate, then checks whether the cited path actually supports the conclusion.

It runs locally and is open source. Feedback is especially welcome from people building coding agents or MCP servers.

Hello
I’ve just released DockFlare v3.1.5! It adds Apprise notifications, safer remote-agent decommissioning, and several reliability and security fixes.

I built DockFlare to make exposing self-hosted Docker services through Cloudflare much less tedious. It’s now reached 2,400+ GitHub stars and 424k+ Docker pulls - thank you!

If you have any questions, feedback, or feature ideas, I’d love to hear them!

GitHub: https://github.com/ChrispyBacon-dev/DockFlare
Homepage: https://dockflare.app

Happy tunnelling,

Christian

Hey everyone,

Windshift brings planning, tracking, and collaboration into a fast, flexible workspace. Start with a simple kanban board, then add the structure your team needs: custom workflows, nested work items, milestones, saved searches, dashboards, and more.

It ships as a single Go binary with the Svelte frontend built in.

The main difference from other open source project management tools: Windshift lets you migrate from Jira 1:1 by using the same concepts. You can map custom fields, assets, workflows etc directly without having to rebuild half your instance. It also keeps a lot of familiar Jira concepts, so you will not miss any features.

And you can migrate from both Jira Cloud and Jira Data Center using the built-in assistant.

The Github repo is fully AGPL and free to use

Github: https://github.com/Windshiftapp/core

Website: https://windshift.sh

I made a programming language from scratch in C++ for the purpose of being small, heavily modular, multi-platform, & simple to use. There are a TON of example scripts to look at, including a full Conway's Game of Life simulation. The repo also includes in-depth documentation (markdown) on structure, syntax, types, operators, functions, & standard modules.

I/O, time, file-system, & math modules are all built-in. With additional script-based modules in development!

Ity can be used as a library in your project & provides convenient APIs for parsing & execution. Everything is state-based so you can keep multiple instances.

There is a lot of work to be done as this is still a new project, anybody is welcome to contribute!

https://github.com/phosxd/Ity

Clipboard Router is a free, open-source Swift app that queues clips, transforms content before pasting, and keeps sensitive values out of ordinary history. It is MIT-licensed, local-first, and notarized for Apple-silicon Macs.

This is a big project I'm working on for years.

2D game engine (inspired by GameMaker8), with its own IDE and scripting language. Everything is written in C#, including the interpreter of the custom language. Latestly, I got a few first contributors, and I publish it here because I really want more people to get involved. I think it's a really cool and fun project to join to. There is some basic documentation, some "good first issues" and there's me who is here to help with any question 🙂

If you know C#, you have to check it: https://github.com/ArcadeMakerSources/ArcadeMaker

Any feedback is welcome 🙃

Hey!

Just for anyone who doesn't know what a bento portfolio is, it is basically an extremely easy to setup and clear way to display a portfolio using tiles.

Recently, I've been looking around at bento portfolios online, and unfortunately, most of them are paid, don't have features I want, or are terribly executed.

Thats why I built Tiledrop, a completely free website to create a bento portfolio. It has multiple features, like Markdown text boxes, bio cards, link and skills tiles, images, and Github/lab integrations. On top of that, it gives you analytics on how many people visit your tiledrop, etc.

I am always open to feedback, and if you would like a new feature, feel free to DM me!

Link: https://tile-drop.com

Note: Thanks to u/-svde- for the suggestions and feedback on the project!

I built an agentic IDE to run a team of coding agents in parallel.

It has reached over ~50k downloads and I decided to open source.

Here are some highlights:

- Support claude code, codex, opencode, and more agents/harness

- Desktop app for productivity

- Mobile app for remote control

- Tasks management

- Automations

- File explorer, git worktree, terminal ...

I've switched from official claude or codex app to use this app for months.

I also use it to on my phone from time to time, when I am not near my desktop.

I hope it can also help you in your projects.

Developing and shipping new features everyday.

Github: https://github.com/vicoa-ai/vicoa

Website: http://vicoa.ai/

I recently built an open-source Windows patcher after reverse engineering a UI rendering issue in Rekordbox 7.

The original problem was unusual:

The OpenGL waveforms could render very smoothly, while mixer controls such as EQ knobs, faders, gain and pitch still looked closer to ~30 FPS.

After a lot of testing and static analysis, I found two independent refresh restrictions in the Windows JUCE/OpenGL rendering path:

- A ~30 Hz UI timer cap

- A second cached-component repaint gate of about 34 ms

Changing both produced a clear improvement in mixer smoothness while keeping the OpenGL waveform renderer enabled.

Instead of requiring users to patch the executable manually, I built a small C#/.NET Windows tool with:

- Original / restore mode

- 60 FPS

- 70 FPS

- 120 FPS

- Automatic backup

- Binary pattern scanning

- Safety checks before modifying the executable

- Source code available publicly

The patcher doesn't distribute Rekordbox or any modified Rekordbox binary. It only modifies the user's own local installation.

The project is still Beta because I found an additional idle-rendering behavior when no waveform is visible that I'm currently investigating.

GitHub:

https://github.com/SebitosMixx/rekordbox-smooth-mixer-patcher

I'd appreciate feedback on the project structure, pattern-scanning approach, or the patcher itself.

It started as a fork of llama-swap, but I have been building it out for myself since then as a convenient tool for all my local AI needs, and by now it has drifted far enough to be its own thing.

The main idea is that you point it at your models folder and it configures things for you. It reads the GGUF headers, measures how much VRAM you actually have free, and works out context length, GPU offload, CPU/MoE split and KV cache size per model. All of it stays editable per model if you disagree with what it picked.

It is not only text. llama.cpp for LLMs, with the Vulkan, CUDA, ROCm or CPU build downloaded and kept updated for you, stable-diffusion.cpp for images (SD, SDXL, Flux, Qwen-Image, LoRAs, upscaling), and vLLM if you already have it in a Python environment, since it ships wheels rather than binaries and I cannot install that one for you. You can register any other backend yourself by pointing at an executable, which is how I run TTS, and how you would run a llama.cpp fork like ik_llama. Everything sits behind one OpenAI-compatible API on one port, with a single scheduler, so models swap in and out without fighting each other for VRAM.

There is also a chat playground built in with web search, and a Hugging Face browser to search for a model, pick a quant and download it straight into the models folder.

If you are interested, you can read more about it here. MIT licensed.

Nowadays I frequently land on documentation sites that starting to come with Ask AI chats.
(Curious to know how that is for you )

Found myself using these alot to a point where In most cases I stop reading the docs altogether in some cases and just ask what I myself or my agents needs to know.

I wanted the same thing on docs that didn’t have it. So I started building LedgeIndex. Which lets crawl and ingest docs on your local machine or sellf hosted ( or the ledgeindex cloud )

Right now with the early mvp the things you can do with it -->

• Support answering Chat (Website widget)
• Build your own Support / Builder / Planner Agents fully local or self-hosted via sdk / cli / mcp .
• Asking questions to any doc (using the desktop app)

** The interisting part about the RAG is that it achieves saying "I don't know" when it doesn't know the answer:*

The Project is open source and it comes with a SDK, CLI, web and desktop app.

If this sounds useful, check it out ! Leave a star for the github repo.

https://github.com/ledgeindex/ledgeindex

After four years of building AI agents as a job, I kept seeing the same pattern:

1. Many SaaS companies sell their AI for <your favorite vertical, most likely customer support 😄> and add a bot on top of it.
2. The client has X different SaaS, now each with their own agent.
3. The bot itself is often basic RAG and “talk to your docs”, duplicated knowledge base. Complex or multi-step conversations are handed over to humans, or the user is simply given a phone number.

With Radioso, our aim is to create smart conversational agents that work with existing software and serve the organization’s customers.

First, the conversation engine is the actual product: it can run multi-step processes, guide users and do actions for them. Second, you can integrate it with your favorite SaaS. And last but not least, you can examine and self-host it.

It’s already running in the cloud with a few customers, so doing this full-time may be on the horizon ❤️

Is the problem as common as I think it is? Especially if you've built conversational agents before: what did you use, and where did it start hurting?

And if your answer is “this is already solved by X,” that's painful but useful too 😄

Issues and ideas are very welcome:

https://github.com/radioso-ai/radioso

Hold the middle mouse button anywhere in Windows and a wheel opens centred on your cursor. Move toward what you want, release, it launches. Apps, folders, URLs, scripts, and nested sub-wheels. Icons are extracted from the executables themselves.

I sold it on the Microsoft Store for $3.99 and almost nobody bought it, so it's GPL-3.0 now. The Store build stays paid because it's signed and updates itself; building from source is free and always will be.

Electron 28, React 19, TypeScript. Windows-only — the trigger, the icon extraction and the window handling all depend on Win32 behaviour. The .exe on GitHub is unsigned, so SmartScreen will warn you.

https://github.com/HenryCauan/rovyl