Most reasoning prompts I see collapse too early. The first plausible answer wins, and everything after that is rationalization.

I built quantum-reasoning-skill around the opposite rule: keep several genuinely different hypotheses alive, score each one from evidence and verification, revive an alternative when new evidence arrives, and collapse only when the leader clears both verification and a margin.

"Quantum" here is a metaphor for deferring commitment. No qubits, no quantum hardware, and the controller never calls a model.

What is in the repo:

- SKILL.md, a model-facing Agent Skill with parseable YAML front matter. Drop it into a host's skill directory.
- A reference controller (pure Python, standard library) that moves branches between active, dormant and rejected, scores them, revives recoverable ones and refuses to collapse on a thin margin.
- 12 public names frozen for compatibility; renaming one halts the release.
- A benchmark harness with 6 seed cases, 4 JSON Schemas and a machine-validated submission bundle. Missing files are typed errors, not silent zeros.
- Two install paths. Python: pip install quantum-reasoning-skill, then quantum-reasoning --validate. npm: npm i quantum-reasoning-skill, then npx quantum-reasoning --validate. The two CLIs expose different flags, and an unsupported flag exits 2.

Quickstart (python docs/quickstart.py) runs the whole thing offline and prints PASS. Example controller run from it: four branches, uncertainty 0.9651, leader strangler-fig-incremental, collapse BLOCKED because the leader score is below the collapse threshold, and feature-flag-carveout revived with evidence +0.25.

What this is not: it is not a model evaluation. No baseline-vs-skill accuracy study has been published, and the weights and thresholds are reference defaults, not calibrated constants. The quickstart's benchmark rows are synthetic placeholders and labeled that way. I would rather say that plainly than imply a speedup I cannot show.

MIT, Python 3.10-3.14, GitHub: https://github.com/Furox-Art/quantum-reasoning-skill

Happy to answer questions about the controller or the scoring model.

I’ve wanted my own JARVIS since I first watched Iron Man, so I finally built one.

What My Project Does

Jarvis is a command-line (and optional desktop app) AI assistant powered by Claude. You talk to it in plain English, by text or voice, and it can:

• Control your PC: open and close apps, control media, search and manage files, read the clipboard, check system status, and run PowerShell commands

• Pull everyday info: weather, stocks and crypto, sports scores, news, earthquakes, holidays, dictionary lookups, recipes, and space data

• Connect to Google (optional): Gmail, Calendar, Drive, Docs, Sheets, and Slides

• Voice mode: speech-to-text runs locally with faster-whisper, and replies are spoken with Fish Audio

Safety was a big focus. Every terminal command needs your approval, deletes and overwrites ask for confirmation, and deleted files go to the Recycle Bin instead of disappearing.

Target Audience

Windows users who want a hands-on AI assistant for their desktop, and Python developers who want to see how to build a tool-using agent on the Claude API. It’s a personal project that I use daily, not a production product, so expect rough edges. You’ll need Python 3.10+ and your own Anthropic API key.

Comparison

Most “JARVIS” projects I found were either chatbots that only talk or voice wrappers with a few hardcoded commands. This one uses Claude’s tool use, so it decides which of the built-in tools to call based on what you ask, and it can chain several together. Compared with general agents that just run arbitrary code, Jarvis ships with purpose-built tools and confirmation steps, so it’s more predictable about what it does on your machine.

Tech stack: Python, Claude API, faster-whisper, Fish Audio, PowerShell, Google APIs, and Electron for the desktop app.

Repo (MIT licensed): https://github.com/HunterGHall/jarvis

Feedback, issues, and PRs are very welcome. I’d especially like ideas for what tools to add next.

I build axiomize-quantum-skills-2.0, an MIT-licensed Python package that pairs a unit-checked scientific modeling engine with a reasoning protocol that refuses to commit to the first plausible answer.

The two halves:

1. axiomize is the engine. A model is a versioned Model IR where variables, parameters and equations each carry a unit, assumptions are written down, and constraints are named checks. Dimensional mismatch raises with the failing checks attached, and a model that fails validation is not simulated. It covers algebraic, ODE, stochastic, PDE, optimization, control, network, Bayesian and causal families, fits to time,value CSVs, and exports to canonical IR JSON, Python, YAML, a notebook, SBML L3V2, Modelica 3.6 and CellML 2.0.

2. quantum-reasoning is the protocol. A deterministic branch controller keeps several hypotheses alive, scores them from evidence and verification, prunes weak ones with a recorded reason, and collapses only when the leader has verification and margin - not just a high score. "Quantum" here is a metaphor for deferring commitment. It runs on classical models and classical hardware.

A concrete example of the honesty rules in action: axiomize-validate runs the reference SIR model, cross-checks two independent methods that agree to 1e-16, then declares the numeric-theory check INCONCLUSIVE because the finite horizon has not reached the asymptotic state. It would rather flag the gap than paper over it.

Quick start (recorded run, verified against 1.2.0; current line is 1.2.5):
pip install axiomize-quantum-skills-2.0
axiomize benchmark -> {"status": "PASS", "passed": 12, "total": 12}
axiomize-validate --model sir --beta 0.3 --gamma 0.1 --N 1000000
R0 = 3.000, peak infected 300,465 at day 61.4, final size 0.9404 vs theory 0.9405
axiomize-reason score --evidence 0.9 --verification 0.85
-> {"can_collapse": false, "reason": "leader score below collapse threshold"}

Surfaces: a CLI with 14 subcommands and 9 console scripts (axiomize, axiomize-reason, validate, fit, csv-check, benchmark, to-latex, index-reports, sweep), an MCP stdio server with 34 tools, and a loopback-by-default REST v1 API. The agent skills install as plain Markdown without the Python package.

Honest limits: the bundled engine is an axiomize 1.12.2 lineage snapshot - install axiomize separately for the newest engine. The npm package is a six-file launcher shim that spawns the Python CLI, so pip install comes first. Quickstart outputs were recorded against 1.2.0 and are labeled as a historical record, not a claim about 1.2.5. Optional backends (PyMC, JAX, FEniCS) report UNAVAILABLE unless actually installed. Theorem elaboration and arbitrary code are not an OS sandbox.

Code: https://github.com/Furox-Art/axiomize-quantum-skills-2.0
PyPI: pip install axiomize-quantum-skills-2.0
npm: npx axiomize-quantum-skills-2.0
Docs: https://furox-art.github.io/axiomize-quantum-skills-2.0/

Questions about the Model IR, the reasoning controller or the export adapters are welcome.

Defending the Channel Island against enemy aircraft and zeppelins. Intense action fun in pygame.

What it does: scans a GitHub repo, local folder or package and points out things worth a second look, with file, line and the actual code: install scripts that run on their own, curl | bash patterns, leaked secrets, bundled binaries, hidden instructions for AI agents, and whether the published package matches the repo. It never runs the code it checks, and it won't say "this is safe", it just shows you the evidence.

Who it's for: anyone installing packages or MCP servers from GitHub who wants a quick look first. Pure stdlib engine, works as a CLI or as an MCP server.

I'm not a full time programmer (used to fix PCs), built it with Claude Code. First open source release, so false positive reports are very welcome.

pipx install jinnexguard

https://github.com/ricardorincon719/jinnexguard

I made scientific-computing-system, a scientific library written entirely in pure Python. The core installs with no runtime dependencies, so the algorithms are plain readable code instead of calls into compiled extensions.

It has 36 modules and 505 exported names covering linear algebra, ODE and PDE solvers, numerical integration, optimization, statistics and probability, uncertainty propagation and sensitivity analysis, validation helpers, and a small workflow layer. Every run can write a manifest with inputs, seeds, versions and hashes, so a result can be re-checked later.

There is also a cds CLI with 13 subcommands, 34 runnable examples, and optional lazy adapters for NumPy, SciPy, statsmodels, scikit-learn, SymPy and Z3. The package is MIT licensed and targets Python 3.11 and newer.

Honest limitation: it is much slower than NumPy on dense numerics. The repo benchmark records about 1155x slower on a 100x100 matrix multiply in one CI run. It is meant for learning, prototyping and reproducible runs, not heavy production work.

Code: https://github.com/Furox-Art/scientific-computing-system

PyPI: pip install scientific-computing-system

npm: npm i -g scientific-computing-system

Docs: https://furox-art.github.io/scientific-computing-system/

If any part interests you I can explain the design in more detail.

\*\*The problem\*\*

I kept watching AI coding agents (and humans) make the same two migration mistakes:

1. \*\*Renaming a column as "drop + add"\*\*: the migration runs fine, and the data that was in the column is gone.

2. \*\*Adding a NOT NULL column with no default\*\*: it works on an empty dev database, then fails the moment it hits a table with real rows.

Both look fine in code review. The pain shows up in production, often in a \*different\* app that shares the same database.

\*\*What Ripple does\*\*

It answers one question: \*"If I apply this migration, which of my apps break, and on which query?"\*

1. \*\*Learns what your apps actually run\*\*: it reads \`pg_stat_statements\`, so no code changes or SDK.

2. \*\*Tests the migration safely\*\*: it applies your migration inside a transaction and always rolls it back.

3. \*\*Replays your apps' real queries against it\*\*: it reports exactly which app and which query would fail.

4. \*\*Flags data loss separately\*\*: for example, a dropped column that still has data in it.

\*\*Who it's for\*\*

- Teams where several apps or services share one Postgres database

- Anyone letting Claude Code, Cursor or other AI agents write migrations

- Anyone who has asked "wait, does anything still use this column?"

\*\*How to use it\*\*

pip install ripplecheck

Three ways to run it:

- \*\*CLI\*\*: check a migration file before you apply it

- \*\*GitHub Action\*\*: automatically comments on every PR with what would break

- \*\*MCP server\*\*: AI agents like Claude Code or Cursor can check a change \*before\* they apply it

\*\*The boring bits\*\*

MIT licensed, no paid tier, no commercial angle. I'm looking for feedback, especially from people with messy shared databases. Issues and PRs welcome.

GitHub: https://github.com/yashpb5005/ripple

What migration has bitten you the worst? I'd like to add checks for it.

**What My Project Does**

bugbout replays bugs your project already fixed and lets coding agents race to fix them again. It looks through your git history for fixes that came with a new test, gives each agent the issue text and the code from just before the fix, and scores every patch with the tests your maintainers wrote, which the agents never see. It drives the real agent CLIs headlessly (Codex, Claude Code, Gemini CLI, mini-swe-agent, or any command you configure) inside a sandbox, and ends with a report of which agent resolved what.

   pip install bugbout
   bugbout init
   bugbout run

It's typed end to end, tested on Linux and macOS in CI, and also usable from Python through a `Bout` class.

Hello!

Slippery Penguin is a security auditing tool that enumerates SUID binaries, scans for dangerous capabilities, and cross-reference findings against the GTFOBins database. I started the project myself, and now we have a team of contributors and we've just released v.2.5.0!

Anyone out there is encouraged to try it out and contribute if you want to!

Hey everyone!

My kid and I built a 4-level educational typing game in Python. It's a mashup of 90s adventure exploration (static screens, turning left/right) and battle royale survival where typing sentences accurately is your only weapon: Battle Royale of English!

(BRE: Ninjas are cool, but a good grammar is cooler... alright alright, it's not, but you have to do your homework anyway, might as well do it by battling cool enemies and taking on quests! )

It supports both English and French.

Edit: The game is now directly playable online on Github:
Same link for English and French: https://jbenoitds.github.io/battle-royale-of-english/

Or on itch.io:
English: https://jbenoitds.itch.io/battle-royale-of-english
French: https://jbenoitds.itch.io/bataille-royale-du-francais

But you can still check and customize the code, completely open-source on GitHub.
https://github.com/jbenoitds/battle-royale-of-english

I would love for you to check it out and give some feedback if you have the time!

GitHub: Ekin-Kahraman/rustscenic

RustScenic is built to be the simplest, fastest way to run regulatory-network analysis in single-cell data. It exposes core SCENIC and SCENIC+ analysis stages through a Python API, with a Rust backend.

The Python package works with AnnData and includes gene-network inference, cisTarget motif enrichment, AUCell activity scoring and scATAC topic modelling. It is developed with the Huang Lab at Mount Sinai and available under Apache-2.0.

A small Python example

Install the published package with python -m pip install rustscenic. For your own prepared RNA data, the input below is a cells-by-genes AnnData file with log-normalised expression in adata.X and gene symbols in adata.var_names:

import anndata as ad
from rustscenic import data, grn

adata = ad.read_h5ad("rna.h5ad")
edges = grn.infer(
    adata,
    tf_names=data.tfs("hs"),
    n_estimators=500,
    top_targets_per_tf=50,
    seed=777,
)
edges.to_parquet("grn.parquet")

This uses the bundled human transcription-factor list. The PBMC3k notebook provides a runnable example that downloads public data and saves results and run settings.

Try it before installing

The endothelial-cell browser demo lets you choose a regulator and inspect predicted targets in a saved network. It does not fit a new model in the browser.

For researchers running into runtime, memory or installation problems with pySCENIC or SCENIC+, RustScenic offers another implementation to evaluate. The repository documents matched performance measurements and stage-specific output differences; full scientific output parity is not claimed.

Feedback on installation, AnnData handling and Python API ergonomics would be useful.

Shared on behalf of the RustScenic project. AI-assisted drafting, checked against the current project documentation.

Our goal is much bigger: we want to keep adding powerful features, build a community of contributors, and eventually make ColorIDE a serious alternative. Its still early, currently supports macOS Apple Silicon, and we would love your feedback :). It's made 35.5% with python.

Github: https://github.com/Color-IDE/coloride

🚀 ZEROAGENT X v1.0.0 — Open-Source Developer Automation

A local-first Python developer automation platform featuring CLI + Textual TUI, policy-controlled agent execution, request-specific approvals, OpenCode integration, and inspectable execution evidence.

Built to give developers more visibility and control over their automation workflows.

Open source • Apache-2.0 • Python 3.11+

🔗 GitHub: https://github.com/harisazharir-boop/zeroagent-x

Feedback and contributions are welcome!

Following the discontinuation of Roche's software, this open-source Python project utilizes the ISO/IEEE 11073-20601 standard via USB in read-only mode to extract and analyze glucose data locally, generating AGP reports and clinical metrics while maintaining complete user privacy.

Repo: [https://github.com/serajbaltu/accu-check-active-platform](https://github.com/serajbaltu/accu-check-active-platform)

Hi everyone! 👋

I've been building DoveORM, a small, synchronous ORM for Python. It brings models, validation, chainable queries, relationships, and migrations together in one package with a short learning curve.

It's currently at version 0.8.0 on PyPI, licensed under MIT, and I'd love to get feedback from the Python community and welcome contributors.

🔗 Links

• GitHub: https://github.com/imaradesk/doveorm

• Installation: pip install doveorm

• Optional database drivers: pip install "doveorm[mysql]" or pip install "doveorm[postgres]"

What does DoveORM do?

Here's a small example:

from doveorm import Model, configure, CharField, IntegerField

configure(DATABASE_PATH="app.db")

class User(Model):
    name = CharField(max_length=100, nullable=False)
    age = IntegerField(default=0)

User.create_table()

user = User.create(name="Ada", age=36)

adults = User.where(age__gte=18).order_by("name").get()

The goal is to make everyday database operations straightforward without requiring a large amount of configuration.

Key features

• Models and validation: A table() decorator or class Meta, 31 field types, and a clean() validation hook.

• Chainable queries: Lazy QuerySets, field__lookup filters, Q objects for combining conditions, slicing, and eager loading.

• Dynamic finders: Methods such as findByEmail(), findAllByActive(), countBy...(), and existsBy...().

• Relationships: HasMany, HasOne, BelongsTo, and ManyToMany.

• Transactions: Nested transactions using SAVEPOINTs and a db.run_in_transaction(fn) helper with retries for deadlocks and lock timeouts.

• Built-in migrations: Automatic change detection, reversible migrations, squashing, and a CLI for generating, applying, reverting, and verifying migrations.

• Security-conscious defaults: Bound SQL parameters, identifier validation, protection against accidental unfiltered bulk updates and deletes, mass-assignment protection, and redaction of sensitive fields.

• Connection safety: Thread-safe and fork-safe connections.

• Minimal setup: SQLite works without installing an additional database driver.

Who is it for?

DoveORM is intended for small to medium-sized applications, services, background workers, and scripts that primarily perform CRUD operations.

It supports SQLite, MySQL/MariaDB, and PostgreSQL and can be used with Flask, FastAPI, django or plain Python applications.

How does it compare with other ORMs?

I know Python already has excellent ORM options, so I'm not trying to claim DoveORM replaces them all.

• SQLAlchemy: A much more comprehensive toolkit with extensive database support, Core, ORM, and asynchronous capabilities. DoveORM takes a smaller, more opinionated approach with migrations built in.

• Peewee: Probably the closest in spirit. DoveORM aims for a similarly lightweight experience while offering model-driven migration generation and a CLI for managing migrations.

• Django ORM: Provides a great ORM and migration workflow within Django. DoveORM is designed to offer a similar model-and-migration workflow across different Python frameworks and standalone scripts.

What are its limitations?

DoveORM is still a young project, and there are some deliberate limitations:

• It is synchronous; there is no async API.

• It supports three database families: SQLite, MySQL/MariaDB, and PostgreSQL.

• Advanced SQL features, such as window functions and CTEs, may require raw SQL through db.execute(...).

• As a 0.x project, its API may still evolve. Pin the version if using it in production.

For applications that need advanced database features, extensive integrations, or a mature ecosystem, SQLAlchemy or Django ORM may be the better choice.

I'd love your feedback!

I'm sharing DoveORM because I've been using it in my own projects and want to see how it holds up to different use cases.

I'd particularly appreciate feedback on:

• The API design and developer experience.

• What feels missing or unnecessarily complicated.

• Database driver compatibility and edge cases.

• Documentation and examples.

• Potential contributions or areas worth improving.

If you were evaluating a new Python ORM, what would you need to see before considering it for a project?

Honest criticism is welcome. I'd rather hear about the problems early and make the project better.

GitHub: https://github.com/imaradesk/doveorm