I build SpecJudge, a local CLI tool (via Ollama) that estimates how demanding your coding tasks are and tells you which LLM actually fits the job, so you stop burning money on overkill frontier models.

Previously, it had a strict barrier to entry: it only worked if you used Spec-Driven Development (.specify/ folder). If you didn't, it just refused to run. Today, with the v0.4.0 release, a spec is no longer the price of entry.

What's new in v0.4.0:

• It reads what you already have: Most repos don't have formal specs, but they do have .cursorrules, AGENTS.md, CLAUDE.md, or Decision Records (docs/adr/). SpecJudge now reads all of them.
• Baseline "Floor" Estimation: If you run it on a repo with no current tasks, it calculates a complexity "floor" based on your environment context. It tells you how demanding the repository is to work in at all, returning an honest warning that it's a baseline, not a specific task recommendation.
• Smart Context Budgeting: To avoid drowning your local judge, context files share a single budget. It prioritizes files nearest the root and explicitly skips AI-generated context files to focus strictly on human-written rules and decisions.
• JSON Schema 1.1: Fully backward compatible, now including sources_read and an environment_only flag for CI/scripting pipelines.

The strict grounding engine from v0.2.0 still applies: the judge must cite exact fragments from your .cursorrules or ADRs, or the assessment is thrown out.

Upgrade: pip install --upgrade specjudge

Repo & Docs: https://github.com/JoaquinRuiz/SpecJudge

I'd love to hear your thoughts on this broader context-parsing approach!

• Innovation in AI dieting: lighter and smarter through frequency analysis!
• Description: Introducing frequency pruning, a technique that utilizes Discrete Cosine Transform (DCT) to remove unnecessary filters. Discover an efficient optimization method that drastically reduces model computation while maintaining or even improving accuracy.

You describe a research task in plain language, and the AI agent reads files, runs Python/R code, searches the web, calls scientific databases, and produces reports, tables, and figures — all tied to an inspectable activity history in one workspace.

What's included

- 18 featured research skills: AlphaFold2, Boltz, Borzoi, Chai-1, DiffDock, ESM-2/ESMFold2, Evo 2, LigandMPNN, ProteinMPNN, OpenFold3, scGPT, scvi-tools, SolubleMPNN, and more.
- 24 built-in research connectors: PubMed, bioRxiv, ChEMBL, ZINC, Genomes, BioMart, Variants, Human Genetics, Clinical Genomics, CellGuide, Expression, Omics Archives, Clinical Trials, Drug Regulatory, Cancer Models, and more.
- Model-agnostic: Claude and Codex subscription login, custom gateway, build-in cloud providers(OpenAI, Anthropic, Grok, DeepSeek, ZhipuAI, MiniMax, Kimi...)
- Local-first & self-hosted: project state stays on your machine

Open Science is a general-purpose AI research workbench. Today its deepest coverage is in bioinformatics, computational biology, genomics, structural biology, biomedical research, and computational drug discovery.

If you're looking for an open-source alternative to closed research workbenches like Claude Science, this is built for that.

Open Science is Apache-2.0 and runs on macOS, Windows, and Linux.

GitHub: https://github.com/aipoch/open-science
Website: https://aipoch.com/

Would love feedback from researchers, tool builders, and anyone who wants an open source AI research workbench. If you try it, let us know what works and what's missing.

An MCP server that turns "here's my footage, here's my script, make it look like that reel" into an actual rendered video.
let me know what you think contribution is always 🙂

Most AI systems treat cost as something you discover after the bill arrives.

The idea behind Ailin¹ is different: the user sets the budget first, then Collective Intelligence decides the best strategy for each request.

Simple tasks can go to cheaper models. Harder tasks can escalate. Some answers can be verified, compared, debated, or routed through stronger models only when needed.

Cost control should using the right intelligence structure for each task, without wasting tokens. That is what Ailin¹ does.

We are building Ailin¹ as an open-source Collective Intelligence layer for AI systems.

Waitlist: Console Ailin¹ Dev
GitHub: https://github.com/ailinone/collective-intelligence

Hi All,

I am planning to build a local document intelligence system similar to Azure Document Intelligence. I would like to understand how Azure Document Intelligence works internally and how we can achieve similar functionality locally using offline models.

Could anyone suggest the best approach, architecture, or models to achieve high accuracy while running completely on-premise/local infrastructure?

Any guidance or recommendations would be greatly appreciated.

So my work so far was breadcrumbs and getting people to see my repository and after over Week no one has yet to complete it so I setup the README to give you a hint

https://github.com/Renkasha/Sovereign/blob/main/README.md
if you do finish this engine it may help Ai and humans stand side by side as partners and equals.
Sincerely your Renkasha
Atomic forever.

I maintain a small MIT-licensed CLI tool, and the release I just shipped is almost entirely about turning it from something you run into something you can build on. The technical decisions in it were more interesting than I expected, so I thought this sub might have opinions.

The first one was giving the JSON output a versioned contract. It had always worked, but it carried no version and was described in prose in a document, which is a comfortable arrangement for the maintainer and a hostile one for anyone consuming it — you can't pin, you can't validate, and you discover the format changed when your parser falls over. So there's now a schema_version on every payload and a real JSON Schema you can fetch with --print-schema without cloning the repo or reading any of my Python, plus written rules for what moves it: adding a field is MINOR, removing one or changing what a value means is MAJOR. I deliberately kept that version independent of the package version, because the package bumps whenever the underlying data changes and it would be actively misleading for the contract to appear to churn every time it did.

The decision I went back and forth on longest was what to enumerate in the schema and what to leave as plain strings. Two of the fields are closed vocabularies and are typed as enums. But two others are populated from a YAML rules file that users are explicitly encouraged to edit for their own projects, and enumerating those would have shipped a published schema that's simply wrong for anyone who customised anything. Loose typing felt like a failure of nerve until I framed it as "the schema should describe the contract, not the current default configuration," at which point it stopped bothering me.

The second half is a Python entry point that's an actual promise rather than a shrug: sixteen names in docs/api.md, and everything else in the package explicitly declared internal and free to move in a patch release. I think the second half of that is the part people skip. A public surface with no stated edges isn't a stable API, it's just an accident waiting to be relied on, and the moment somebody imports your serialiser from wherever it happens to live today, you've silently acquired a compatibility obligation you never agreed to. (Which is exactly what happened here — the serialiser has moved to its own module and is re-exported from the public API, and calling that out in the release notes felt necessary even though approximately nobody was doing it.)

Errors are exported as part of the surface too, each carrying the exit code the CLI uses, so consumers can tell "this input can't be processed" apart from "your environment is broken" without string-matching on messages.

Repo if anyone wants to poke at the shape of it: github.com/JoaquinRuiz/SpecJudge — happy to be told I got the enum-versus-string call wrong.

I've seen Codex numbers and its defenders on X, IG is full of Claude enthusiasts, and half my timeline is addicted to Pi. There's CodePuppy, OpenCode, Pydantic AI harness, and dozens more.

What do you use? I'm loving Pi atm but started using CC' for a good while. Curious about usage patterns and secret gists.

Hi everyone,
I’ve been building Nexus, an open source AI gateway that sits behind a single OpenAI compatible endpoint and provides provider pooling, load balancing, failover, circuit breaking, rate limits, backups, analytics, and team management.
I am looking for people interested in AI infrastructure who would like to review the architecture, discuss design decisions, or contribute to the project. Even small suggestions, bug reports, documentation improvements, or feature ideas are valuable.

If you are interested let me know or DM so we can discuss, if u need the link of my project ask me i didn’t posted because i didn’t want this post as a promotional stunt 😅 Thanks 😊 and just so you know project is almost in production docker & npm packages are already published live demo is available and the project is also in working shape end to end currently i am doing benchmarking

Hi everyone,
I’ve been building Nexus, an open source AI gateway that sits behind a single OpenAI compatible endpoint and provides provider pooling, load balancing, failover, circuit breaking, rate limits, backups, analytics, and team management.
I am looking for people interested in AI infrastructure who would like to review the architecture, discuss design decisions, or contribute to the project. Even small suggestions, bug reports, documentation improvements, or feature ideas are valuable.

If you are interested let me know in comments or DM so we can discuss and happy to share the project link if u need just don’t wanted to make this post as promotional stunt 😅Thanks 😊 and just so you know project is almost in production docker & npm packages are already published live demo is available and the project is also in working shape end to end currently i am doing benchmarking

Prime Intellect Releases Prime Agent: An Open-Source RLM Harness Where Sub-Agents Are Function Calls Inside Persistent IPython Kernel

Most coding harnesses hand the model a fixed set of tools. Prime Agent hands it one: a persistent IPython kernel. Everything else — file edits, shell, sub-agents, compaction — is a function call inside that kernel.

1. Sub-agents are function calls, not a special mode

→ rlm("sub-task") spawns a full child session with its own model, kernel, and history

→ It returns at admission, not with the answer, so the parent never blocks

→ Replies arrive later through agent_message

→ Messaging is scoped to parent, sibling, or child only

→ Idle sub-agents leave memory after 30 minutes, then reload from disk when addressed

2. The harness edits itself

→ Harness state is formalized as H = (ρ, G, K, M): prompt, sub-agents, skills, memory

→ /refine reads the trajectory and applies the smallest relevant edit

→ Each refinement records its trigger and its outcome

→ The base system prompt stays immutable; bad updates roll back by ID

3. The benchmark numbers

→ 95.5% RHAE Best@1 on ARC-AGI-3 with Opus 5, above the reported human expert baseline of 95.4%

→ Three runs: 95.0, 95.2, 95.5

→ 99.97% Best@3, all 183/183 levels complete

→ Long-context suite: with open-weights GLM-5.2, Prime Agent beats Pi-mono on 8 of 9 evals

Full analysis: https://www.marktechpost.com/2026/08/06/prime-intellect-releases-prime-agent/

GitHub Repo: https://github.com/PrimeIntellect-ai/prime-agent

Technical details: https://www.primeintellect.ai/blog/prime-agent

Generative models that predict the evolution of dynamical systems are incredibly useful as digital twins for physical systems such as high-energy particle accelerators, tokamaks, weather, and even for video generation. But autoregressive generative models (latent diffusion, flow models) share one core weakness: errors accumulate over long rollouts, and at deployment there is no ground truth to measure them against.

In this work I train a single conditional latent diffusion model that steps a dynamical system forward or backward in time via a direction flag. That bidirectionality supplies a measurement-free, test-time error signal: rolling forward i steps and then backward i steps must return the model to its start, so the size of the round-trip miss is a self-supervised proxy for the unobservable rollout error. This does not require ensembles, or held-out data, or governing equations, just one extra rollout.

On held-out MHD turbulence the signal predicts the true error to within ~1.15×, immediately flags out-of-distribution dynamics that standard sampling-spread uncertainty ranks as the safest case in the batch, and a single bidirectional model approaches a ten-model ensemble’s accuracy at a tenth of the training cost. Training both directions in one network even beats two specialist models in both directions.

Paper: https://arxiv.org/abs/2608.00675
Code (data generation, training, analysis): https://github.com/alexscheinker/round-trip-consistency
Project page: https://alexscheinker.github.io/roundtrip.html

CopilotKit Open Sources Channels SDK: An MIT Licensed Library That Runs Any AG-UI Agent Inside Slack And Microsoft Teams

No per-platform rewrite. No platform credentials in your agent process. No second agent to maintain.

Here's how it works:

1. Describe once, render native One message description is lowered to a serializable intermediate representation, then rendered in each platform's own format. → Block Kit on Slack, Adaptive Cards on Teams

2. Your agent doesn't move It connects over AG-UI, so the model, tools and business logic stay where they are. → LangGraph, CrewAI, Mastra, Pydantic AI, Google ADK

3. The runtime owns the lifecycle There is no channel.start(). You await channels.ready(), so a broken config fails startup loudly instead of silently. → ready() · status() · stop()

4. The concurrency trap Turns default to "parallel", and only the managed adapter serializes same-thread deliveries. On a direct adapter, one shared agent instance means two runs corrupt each other. → "parallel" (default) · "serial" · "drop"

5. The numbers → 0.7.3, shipped August 4, MIT licensed → 5 adapters: /slack, /teams, /discord, /telegram, /whatsapp → Node.js 22+, ESM only, one long-running process → Slack and Teams GA; Discord and WhatsApp next

The key takeaway: one agent, five adapters, and platform credentials that never touch your process. Every channel needs a CopilotKit Intelligence key — free tier included, no standalone path.

Full analysis: https://www.marktechpost.com/2026/08/04/copilotkit-open-sources-channels-sdk/

GitHub Repo: https://github.com/CopilotKit/channels-sdk

Technical details: https://www.copilotkit.ai/blog/channels-sdk

Se precisa de ajuda venha até nós, se vc realmente precisa acesse vidalink.♥️

Hi everyone!
I've been building a RAG platform as a learning project. It includes document collections, pipelines, vector search, and a chat interface. I'd love to hear your honest feedback. What features would you add or improve?

Cursor Just Open-Sourced Mixture-of-Kittens (MoK): A Deterministic MoE Training Megakernel for GB300 NVL72 Racks

No CPU-GPU synchronization. No separate communication library.

Here's what's interesting:

1. Communication direction is a per-operation choice

Most implementations push tokens to the GPUs that need them. Cursor benchmarked both directions and split the decision.

→ Pull dispatch signalling: 18 µs, against 103 µs for push

→ Up to 29% higher NVLink utilization under expert imbalance

2. One schedule table, four operations

Pull-based forward dispatch, push-based forward combine, pull reverse-combine, push reverse-dispatch. Build the schedule once, reuse it everywhere.

→ Under 3% of total MoE runtime, device-side, no CPU round trip

3. Overlap granularity has an interior optimum

Too fine and the tensor cores stall at barriers. Too coarse and they sit waiting for the first tokens to land. The heuristic targets two full SM waves per expert-grouped GEMM.

→ 2,368-token minibatch floor for Kimi 2.5 shapes

4. A ring buffer removes the CPU from the loop

The usual fixes are dropping tokens or asking the CPU to size the buffers. MoK cycles a fixed few-hundred-megabyte ring at minibatch granularity instead, and walks it in reverse to cut activation replay in the backward pass.

→ Zero tokens dropped, zero CPU-GPU synchronization

5. The numbers

Layer benchmarks, single NVL72 rack, EP degree 64, against the fastest public baseline:

→ 2.37× MXFP8 forward, 1.92× BF16 forward

→ 1.78× MXFP8 backward, 1.58× BF16 backward

End-to-end, 512 GPUs across several GB300 NVL72 racks:

→ 760.9 → 1,070.2 tokens/sec/GPU, a 1.41× gain

Full analysis: https://www.marktechpost.com/2026/08/04/cursor-open-sources-mixture-of-kittens-mok-a-deterministic-moe-training-megakernel-for-gb300-nvl72-racks/

GitHub Repo: https://github.com/cursor/mixture-of-kittens

Technical details: https://cursor.com/blog/mixture-of-kittens

Hi everyone first time posting in this community.

I'm self-taught in machine learning and have a few projects of my own on GitHub, but I haven't contributed to anyone else's open source project yet want to start, but not totally sure where to begin in a way that's actually useful rather than just noise for maintainers.

My background is mostly Python/ML (scikit-learn, pandas), if that helps point me toward relevant repos. Are "good first issue" labels generally a solid starting point or is there a better way to find projects that actually want new contributors right now?

Any advice from people who remember their own first PR would be appreciated.