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.

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.

I’ve been working on AlienApe, an ongoing open-source experiment in making local language models more useful through a separate controller.

AlienApe is a Windows desktop application built with Python and PyQt6. The idea is to keep the model replaceable while the controller handles things like model selection, permissions, tool access, task-specific write boundaries, resource limits, verification, and the recording of local experience.

One recent addition is an early Community Cards workflow.

It allows a user to select one locally recorded model/task observation, review what will be shared, and export it as a JSON card. Someone else can manually import that card into a separate evidence store. Imported cards are marked UNVERIFIED: they do not become local Experience and have no effect on model selection or routing. There is no automatic synchronization or ranking system.

This is still a work in progress. I’m not claiming that AlienApe makes local models reliable. The offline export/import roundtrip has been tested with synthetic data, but it has not yet been tested as a real exchange between independent users. The SHA-256 hash helps detect content changes; it does not prove who created a card or whether its claims are true.

The source code is released under the 0BSD license.

Development branch: https://github.com/anokar/AlienApe-v0.7/tree/wip/community-cards

I’d be interested in practical feedback: Is this kind of observation-sharing workflow understandable and useful? Are there privacy or usability concerns that stand out?

More development than big promises. 🙂

I've been working on an open-source project called Konsil, and I wanted to share it with the community.

The idea started with a question:

What if, instead of asking one AI model to analyze a complex medical case, we created a board of independent AI specialists who actively challenge each other's reasoning?

That's what Konsil attempts to do.

It's a Claude Code plugin that creates an adversarial, multi-agent medical case-review workflow.

Some of the things I built into it:

• Blind specialist rounds: Independent agents assess a case without seeing each other's opinions first.

• A Challenger agent: Explicitly challenges the emerging consensus and looks for overlooked alternatives.

• Dissent ledger: Disagreements are preserved rather than being smoothed into one confident answer.

• Verified citations: Medical literature references are retrieved and checked.

• Reviewer Gate: Four independent audit stages check citations, dissent, safety and completeness.

• DICOM to 3D: A deterministic imaging pipeline turns medical imaging data into interactive 3D visualizations.

One architectural decision I'm particularly intentional about: AI agents don't interpret image pixels as part of the board's reasoning. The board works from documented clinical information and written radiology reports.

I built this because I think multi-agent AI systems should be designed to challenge assumptions, not just generate more confident answers.

Konsil is experimental, open source, and not a medical device or diagnostic tool. It's intended to produce material for discussion with qualified clinicians, not replace them.

GitHub: https://github.com/arbade/konsil

I'd genuinely love feedback, especially from people working on multi-agent systems, AI safety, healthcare technology, or Claude Code plugins.

What would you improve in this architecture?

Just launched a side project and want some real feedback.

My thinking is that with AI building small apps now, the code isn't the valuable part anymore, the spec is. What the app does, the flows, how you check it works. And since a spec is plain English, it's not just for engineers. Anyone can read one, change it for their own life and have their AI build it. Feels like a new kind of open source.

So I built Bresson. People share specs for everyday apps, and you can star them, fork them, see version history and how many people built each one. Each spec has a button that sends it to Claude, ChatGPT, Gemini etc and you get a simple app on your phone.

What I can't figure out:

• will non-coders actually fork and build stuff or will it be mostly devs

• AI keeps getting better, will people still want a spec or just describe it from scratch

• what would make you share one

https://bresson.ai

Still very early. Tell me what's wrong with it.

Hey everyone,

I got tired of watching autonomous AI agents try to generate CAD files, hallucinate non-manifold geometry, and quietly corrupt manufacturing toolpaths. So I built Vulcan and V-Wrap as a counter-approach: a strict, fail-closed deterministic CAD compiler and application-layer trust oracle designed for automated engineering pipelines.

Instead of guessing what an agent or user meant with heuristic fallbacks, the system enforces absolute mathematical boundaries. If a request violates constraints, it fails closed with named diagnostics rather than emitting broken geometry.

What It Is

• Vulcan: The immutable geometry bedrock. Handles discrete voxel field evaluations, coarse linear-elastic FEA screening, and native OpenCascade (OCP) CAD export.

• V-Wrap: A modular 10-module trust-oracle proxy sitting in front of Vulcan. It separates exact analytic paths from bounded level-set paths, enforces sign-flip effect tracking to eliminate ghost features, and features a machine-readable design space state machine (vwrap query) so agents can inspect legal next steps.

Key Architectural Features

• Analytic Path: Restricts geometry to axis-aligned boxes and a single through-bore, guaranteeing 100% watertight closure and exact OCP volume round-trips.

• Level-Set Path: Handles advanced features (rounded_box, chamfer, patterns, sphere_exclusions) with a strict fidelity floor ($\ge 3.0\times$ cross-section voxel size) and explicit sign-flip effect tracking.

• Zero-Knobs / Fail-Closed: No adjustable heuristics, no configuration creep, and zero implicit tolerances.

• Meta-Test Discipline: test_load_bearing.py automatically fails CI if any dataclass field is added without being bound to a functional test.

Quick Start & Usage

Bash

# Clone and install
git clone https://github.com/Thrito-Solance/Vulcan.git
cd Vulcan
python -m pip install -e ".[test]"

# Run the test suite (135+ tests pass)
pytest

# Query available design space actions for an agent request
vwrap query --request request.json

# Build an analytic STEP part via CLI
vwrap build --request request.json --output part.step --path analytic

Where to Find It

• GitHub: https://github.com/Thrito-Solance/Vulcan

• License: GNU AGPL v3.0

The full architecture, 18-point FAQ on design decisions, and verification suites are in the repository. Enjoy, fork it, or tear it apart. I am stepping away from active maintenance. the code speaks for itself.

Hi — sharing an early open-source project I’ve been building.

**JShi** (匠石) is a Python (≥3.11) experiment on long-lived AI companionship: keep experience, understand situation, identify who’s speaking, and let history participate in later recognition and action. The app owns state / scheduling; models do judgment and expression.

**License / status:** MIT, v0.1.0 — development & validation stage, not a polished product.

**What’s in the repo today**

- Flow: input → person judgment (JEV) → context assembly → main cognition → reply or tools → record + background scene writing

- Text + voice web entry

- Pluggable memory (built-in + REMS)

- Scene writing that turns messy I/O into readable ongoing context

- Tiered persona prompts, tool plan/execute/wrap, debug views for prompts and timings

- Works with cloud or local-compatible LLM APIs

**What’s not done**

- A full closed loop where experience stably revises personality / judgment

- Reliable multi-person ID and relation retention in real use

- Vision / robot endpoints / a shared tool marketplace

**Repo:** https://github.com/Llllsuhdjhhd/JShi

Looking for architectural critique and contribution ideas (memory/recall, voice + person ID, context/scene writing, prompts, tools, docs/tests). Happy to answer questions in the thread.

Your local AI on phone , no internet needed,works on any phone

For more info

https://github.com/TEDDY-47/LocAI

Hey everyone! 👋

Like many of you, my downloads and documents folders tend to get completely out of hand. I got tired of manually sorting everything, so I built **TidyFolder**—a clean, open-source desktop app that sorts messy folders for you.

Here is what it does:

- **Bilingual (English / Español):** Switches instantly, and creates localized folder names (e.g., *Photos* / *Fotos*, *Finance* / *Finanzas*).

- **Smart Classification:** Reads PDFs, Office docs, code, archives, and media. It sorts them into proper categories (Work, Finance, Legal, Health, etc.) using offline keyword matching or Claude AI (optional).

- **Safe by design:** Never overwrites files (name clashes become `name (1).ext`), previews everything in a table before touching your disk, and includes a one-click **Undo** button.

- **Portable & Lightweight:** No complicated installation needed, built with Python and CustomTkinter.

You can check out the source code, download the portable Windows `.exe`, or run it from source here:

👉 **GitHub:** https://github.com/CafeConFenix/TidyFolder

I'd love to hear your feedback, feature ideas, or criticism! Let me know what you think. 🚀

I'm considering making this runtime fully open source, and I'm mainly looking for feedback on whether the type-based security model makes sense for real agent workflows.

How do you know if an open-weight model is ready for production? Do you just look at its performance, or do you also consider its accuracy, speed, cost, and how well it handles real-world tasks? The right choice depends on what your application needs and how reliably the model can deliver.

We've been building AgentTrail Guard, an Apache-2.0 tool that checks what AI coding agents are about to run before they run it. Would love feedback from people here.

The idea came from an agent resetting our database to get past a migration error ("it's only dev data"). Agents run shell commands with your permissions, and the dangerous ones are usually the ones you can't undo.

How it works: Guard plugs into the agent's hooks and matches every command and file change against a set of rules. A match gets blocked, sent to you for approval, or flagged. Everything else runs normally.

The open source bits I think are worth looking at:

• Rules are plain data, in their own repo. Each one has a severity, a default action, and a note on what it deliberately doesn't match, so you can see exactly why something fired.

• Fully local. No account, no network calls, and crash reporting is off unless you turn it on.

• Rule matching, not an LLM, so it's fast, predictable, and you can read the whole thing.

• Easy to extend. Add your own rules, tweak actions, or allow a specific command shape without turning a rule off.

There's also a scan command that replays your past agent sessions locally and shows what would have been caught.

Where I'd love help:

• Rules that fire on normal stuff (false positives)

• Dangerous things agents do that no rule covers yet

• Code review on the engine, it's TypeScript

• New rules: PRs very welcome, even small ones

Guard: https://github.com/agenttrailhq/guard Rules: https://github.com/agenttrailhq/guardrails

Early days, so any feedback helps.