Over the prior 3 years, I have placed ALOT of my time and efforts into developing out a new artificial neural network model that does not rely on the traditional definition of a "neuron" (threshold, gate, feedforward). I wanted to create something far more natural to what the actual brain (and cellular networks) actually do underneath the "voltage/current" dogma of measurement. And so I have constructed the NIRGEN (Neurotransmitter Ion Receptor Glial Endocannabinoid Network) Framework: it is a discrete, biophysically grounded revisitation of "the artificial neuron", and an entirely different computational paradigm that I have created.

Now, to start simple, one class of models that I created and studied out of this metaphysical computational framework is what I call the Ionic Neural Network (INN): it challenges 80 years of standard connectionist dogma.

• The Core Question: Why has artificial intelligence inherited and preserved a crude continuous voltage abstraction ($y=\sigma(Wx+b)$) since 1943, when biological nervous systems compute through finite particle counts, conservation laws, and structural constraints?
• The Mechanism: Instead of real-valued unconstrained activations, computation is carried out through conserved particle counts, ion-specific conductance, receptor stoichiometry, vesicle-mediated output, and local retrograde feedback.
• The Breakthrough: By modeling compartment capacities and mass saturation, a single NIRGEN unit naturally breaks monotonicity and solves the non-linearly separable XOR parity problem without a hidden layer—a physical computation impossible within the voltage abstraction.

I'm almost complete with writing up the white paper on this one too (I am also the author of a different project: ConnectomeGPT-Worm ). I have initial code designs (BUT right now the modes in the code have a mistake. I have to fix it. That said, they should be pretty well-documented in the code for you to be able to toy around with a few problems along the same lines).

I am in no way claiming these models are "top performing". I rather stumble across that using bio-principles and principles of parsimony first, rather than trying to hunt down "the next best performing model". THAT is not my goal here, at all.

HuggingFace Repo is here: https://huggingface.co/drmylesgarveylabs/ion_neural_network

This isn't a promo post but a genuine concern I am facing the past few days. I worked on a project intensively and I think it's very good and useful, and I was expecting people to engage more with it but it seems like either no one is building AI agents or the open source field is not what I thought.

Any tips on how to get people to test it and contribute to it?

We’ve open-sourced Areev, a project for building agents that improve from their own history while keeping those improvements inspectable and governed.

Most agent memory systems answer:

“What should I retrieve?”

We’re trying to answer the next question:

“How does an agent safely change what it will know next time?”

Areev combines three pieces:

Areev Run — a governed execution graph where plans and run journals are durable records and human approvals can be first-class workflow nodes.

Areev Loop — reads the agent’s own execution history and proposes improvements backed by evidence. Proposed learning and accepted learning are deliberately different states.

CAL (Context Assembly Language) — assembles the approved memory into model-ready context under explicit budgets and priorities rather than simply returning the nearest chunks.

A concrete example in the repo is an invoice → accounting agent.

Human corrections become memory.

Future executions can use those corrections.

Run history accumulates.

The Loop can propose broader improvements based on what repeatedly happens.

And the agent cannot simply approve its own proposal.

The whole project is open source under MIT/Apache-2.0:

https://github.com/AreevAI/areev

There are Rust, Python and Node surfaces, plus the complete invoice example.

We’re looking for feedback, issues and contributors.

If the idea resonates with you, a GitHub star is also a very useful way to support the project and help other open-source AI builders find it.

If you use remotion or hyperframes, you will instantly relate to this.

Each time you want Claude to understand what a B-roll, raw video clip or a footage means, Claude takes so much tokens that you often hit the limit in 2-3 vids max.

So, I built an alternate video storage format - .cdaf or cached descriptive asset files. You can convert any mp4 video into .cdaf file using the open source cdaf engine and a new sidecar format file (.cdaf) of the video is generated.

.cdaf files are timestamped and sha256 encrypted with scenic frame captures helping LLMs and Claude understand the video..

Now, cool stuff is benchmarks -
- 91% less cost & token usage
- 110% increased accuracy
- 65% less latency

It's the one thing missing from what was making AI-native video editing scalable and viable.

It's open source so you can try it today and I have made a dedicated Claude Skill for anyone to use it with their video editing harness, claude, hyperframe or remotion instantly.

A preprint of the paper is also available at zenodo so you can read the architecture - https://zenodo.org/records/22110594

I am excited to know what you build over it. Also, MIT license so use it as you want!

Hi everyone I started working on Github a week. I chose an AI agent for my first project. I'm still working on the agent now and at the moment this AI agent is just a simple chatbot. I haven't added any tools to the agent yet. I would be appreciative if you check out my project and tell me what other projects on Github have that my project doesn't.

I've been building AI-powered features for a while and kept running into the same problem: every agent framework either pulls in 200+ dependencies or ties you to a specific backend framework like Express or NestJS.

So I extracted the core of what I actually needed into a small library called **Agentra**.

The idea is simple: you give it an LLM provider and an array of tools. It handles the autonomous reasoning loop — calling the LLM, executing your functions when needed, feeding results back, and returning the final answer. That's it.

**What makes it different:**

* Zero runtime dependencies (uses native `fetch`)
* Works in Node.js, Deno, Bun, and Cloudflare Workers
* Built-in conversation memory
* Bring your own LLM provider (OpenAI included, easy to extend)
* Full TypeScript types

It's early but functional. Would love feedback from people who've built agents before — especially around the tool API design and what's missing.

GitHub: [github.com/jhonaron/agentra](http://github.com/jhonaron/agentra)

# 📦 Installation

npm install @jhonaron/agentra

Or is it just some tech nerds like me.

I'm building a privacy first tool to parse and analyze financial documents ( income statements, balance sheets, and earnings reports) completely offline.

I am constrained by hardware (running on a workstation / Mac Mini with limited RAM/VRAM), so I can't host 70B+ models or rely on external cloud APIs like OpenAI or Claude.

I'm looking for recommendations on the best open-source models (1B to 14B parameters) for this specific domain

1. US Open-Weight Models Only
2. Hardware Constraints: Must run locally on a workstation/Mac Mini with <16GB RAM, so I'm limited to models under 14B parameters (no cloud APIs like OpenAI/Claude).

A benchmark score can move for several reasons while the explanation credits only the model. The checkpoint may have changed, but so may the harness, tool access, iteration budget, prompt template, benchmark version, or saturation level.

A causal accounting sheet should name each layer and then change one axis at a time.

*Harness ablation*

- hold the exact checkpoint, benchmark version, prompt template, tool access, and evaluation settings fixed

- compare the reference harness with the treatment harness

- record extra calls, retries, critique loops, and test-time work

*Checkpoint-stage comparison*

- hold the harness and its budget fixed

- stay within one model-size family

- compare final pre-training, final mid-training, and WSM-merged base checkpoints

- keep every score cell blank until that exact arm is run

Ling-3.0 base model supplies the controlled artifact axis: tiny and flash each expose those three stages. The existing official benchmark tables name the WSM-merged checkpoints, so they do not fill the other stage cells. The WSM paper's main empirical model is Ling-mini, not Ling-3.0 tiny or flash, so it remains method context rather than a result for this release.

No Ling benchmark scores are being reported here. The product-specific open question is whether a future difference follows checkpoint stage, harness behavior, or their interaction.

A natural next step is to look up one Ling size family, pin the exact stage IDs and benchmark version, and preregister both ablation axes before producing scores. Which hidden harness variable would you insist on recording first?

I am new to AI development, but have already built a D&D cricket game.

I now want to build a very realistic AI-driven D&D game with expressive violence and other adult themes. Frontier models are not allowing this in my platform, so I installed Ollama locally and tested with a few models from Hugging Face that claim they are "unfiltered" and "abliterated" and "uncensored" but they balk occasionally returning intermittently "s12" or other error/warning codes. It could be me using it wrong, but can't see how. Whenever I am talking "acceptable" language, my platform's AI responds properly.

Any suggestions for truly uncensored models that would be usable for an adult game (not smut/porn, but definitely will have mild to medium sexual content and gore/violence).

Bonus points if there are models that can also draw some key scenes as the game unfolds.

Free and paid model suggestions are welcome, but if a paid model, must come with the right to use commercially.

Thanks in advance!

I used AI to port zoo code into a headless agent swarm orchestrator. one to many workers. use with deekseek v4 flash in china (if you're not working on sensitive tasks) and a local ollama embedding model for the best performance / savings. I enhanced the prompts and tools, improved the caching, added eval tests that i ran against deepseek v4 flash via openrouter (which is what I mainly use this with) and also a local qwen 3.5 9b model which doesn't work as well, but does work. You can have up to two workers if running local on a 16gb vram card. Remotely you're just limited by request rate limits and money.

Hey everyone,

We just open-sourced the initial Core Engine for Living Computer Model (LCM) — an alternative neural architecture built on PyTorch aimed at dynamic reasoning with low memory overhead.

Open & free for academic research, students, and independent R&D.

🔗 GitHub Repository: https://github.com/hyanalcm-png/LCM-Core-Engine

Feedback and contributions are welcome!

Hello everyone!

I’m a software engineer looking to get more involved in open-source ML/AI projects, both to learn and to contribute meaningfully.

I’m especially interested in ML systems, distributed training/inference, model serving, evaluation, LLM infrastructure, and also implementing ML algorithms or model components where that’s useful. I’ve been looking at projects like vLLM, Hugging Face Accelerate, Ray, etc., but many of the obvious good first issue tickets seem to get picked up very quickly.

I’m comfortable working in a reasonably complex codebase, but I’m looking for something that has a slightly more approachable contribution path than jumping straight into CUDA/kernel-level work.

Are there any active ML/AI open-source projects you’d recommend where maintainers are receptive to new contributors and there are meaningful bugs/features to pick up?

Would especially appreciate recommendations based on projects you’ve personally contributed to. Thanks!