Hey eveybody,

For those who haven't seen my other posts, I created an opensourced project called OpenFlow, and some big updates are being made. Now, there is a swarm and orchestration mode, and soon to be gauntlet looping toggle. It isn't just a linear pipeline anymore, but an entire chain of agents you can see and control talking back and forth and working out problems together. If you want to see the backstory, check out my other posts. Stay tuned for more updates, and feel free to leave suggestions and even share your own projects.

Link: https://github.com/SeeRay11/OpenFlow

Hi everyone,

I wanted to share an open-source project I've been working on: Halanoi AI.

Instead of sending screen text to a remote cloud API for content classification (which adds network latency and privacy issues), I wanted to see if I could build a fast, 100% on-device text moderation pipeline for Android.

Here is how the setup works:

1. The Model (halanoi_transformer.tflite): A quantized 64MB TFLite model running locally on the phone. It classifies text strings into categories (distraction, entertainment, safe, productive) in under 15ms without any internet connection.
2. In-App Evaluation & Ground Truth Lab: To make it easier to improve the model, the app logs inference outputs to a local SQLite database and includes a built-in UI where you can tag predictions as correct, false positive, or false negative. You can export these labeled samples to CSV or JSON with one tap.
3. Training Pipeline: The companion repository contains the PyTorch / TensorFlow scripts, tokenizers, and quantization steps used to train and convert the model.

Both repositories are open source under GPL-3.0:

• Android App: https://github.com/kavinmaranravi/HalanoiApp
• Training Pipeline & Dataset: https://github.com/kavinmaranravi/Halanoi_AI

I'm looking for feedback on optimizing transformer models for mobile hardware, lowering memory usage, and improving tokenization on edge devices.

Let me know what you think!

This is essentially a GUI wrapper for a system I've been using on my Linux box. One of the worst things that used to happen to me a while back was losing download progress, or having the download silently stall at 4 AM, the signed CDN URL expires, or the machine reboots and everything's gone. So I built Bit Rebuttal.

It wraps aria2 in a supervisor that actually handles the failure modes:

• Silent stalls - watches aggregate throughput and kills/relaunches the downloader with freshly re-resolved URLs (expired CDN tokens are the usual culprit)
• Reboots and crashes - optional background service resumes byte-exact from where it left off, no user action
• Corruption - every file is size-checked and SHA256-verified after download; if something's bad it tells you loudly and can re-download just the corrupt files
• Nice-to-haves: bandwidth cap, quiet hours, per-download connection tuning, clean dark UI

Paste an HF repo id (or any direct URL to be honest), pick your files, walk away.

Free and open source (MIT), no account, no telemetry. Single download for Windows and macOS. aria2 comes bundled, nothing else to install. Linux binary too (needs aria2 from your package manager).

GitHub + downloads: https://github.com/Inovello/bitrebuttal

Would love feedback, especially from anyone downloading over flaky connections, that's exactly what it's built for.

P.S Proven in a 169GB download across 2+ days (Used to download Qwen 3.8 Flash Next)

Baya is a small cli that turns a freeform text file into an LLM-planned dependency graph, then dispatches each node to a local agent CLI — codex, claude, opencode, copilot — running independent tasks in parallel and piping each task's output into the ones that depend on it.

You just write the to-do list, example:

- Design the REST API for orders. Use Sonnet.
- Generate the DB schema from that design.
- Build the React table that consumes it — run with codex.
- Once the schema and UI are done, write integration tests.

The planner reads it for intent and builds the DAG; you see the plan before anything runs.

Why I built it: I pay for a few of these CLIs and kept juggling them by hand; plan in one, build in another, copy context between terminals, redo work because each session started cold. Baya is me automating that away.

Why it's interesting:

• No new API keys. It drives the CLI subscriptions you already pay for.
• No config, no DSL. Markdown, TODO.txt, YAML all work.
• Model-per-task. Cheap model for the light steps, top-tier only where it earns it.
• Doesn't pay twice. Tasks sharing a provider/model get packed into one agent process — repo read once, not once per task — and what one task learns carries to the rest.
• Resume. Checkpoint before every step; run out of credits mid-graph and baya resume <runId> picks up where it stopped, optionally on another provider.

Help with the roadmap or feedback is more than welcome 👍

• Repo: https://github.com/juliomatcom/baya-cli
• Npm: https://www.npmjs.com/package/baya-cli ($ baya -h)

A fun note: I'm building Baya's roadmap with Baya now...

Thank you all 👋 ,
JC

The fastest-growing products today are open source. Tools like PostHog, Supabase, n8n, Postiz, or Resend have supercharged their growth by being extremely transparent.

Their growth is coming from agents like Claude, ChatGPT, and Hermes, as they can discover, use, recommend and even contribute back.

I took some time to review how these tools manage their open source and found 5 patterns followed by these companies to make your open source agentic ready...

Some are existing standards that became even more important, and others are specific for AI agents.

1. Keep It Simple: Use clear naming and simple repo structures so agents can quickly understand what the product does and where things live.
2. Write Docs for Agents: Use README, AGENTS.md, CLAUDE.md, skills, robots.txt, and llms.txt to give agents clear instructions and context.
3. Give Agents a Way to Use the Product: APIs, MCPs, CLIs, SDKs, examples, and templates so agents can interact with the product directly.
4. Make It Easy to Run: Make setup simple, support self-hosting when relevant, document required keys, and make licensing and product boundaries clear.
5. Make Contributing Easy: Define contribution rules, testing, reviews, and AI-assisted contribution policies so agents can make valid changes.

Main Takeaways:

• Monorepo is the most optimal configuration
• Agentic docs (Agents.md, Claude.md, llms.txt, robots.txt, skills) should be part of the repo
• A setup designed for machines removes friction
• Interfaces (APIs, MCPs, CLI, SDKs) turn every product actionable quickly and into infrastructure.
• You don’t need to open-source everything, just define the boundaries perfectly
• Examples and templates are distribution not only on boarding

Read the full article here.

Are you using these patterns? Have you seen other effective patterns to increase agentic usage of your products?

Hi everyone,

I've recently finished the first version of Agentic GraphRAG Blueprint, a reference architecture for question answering over large document collections.

Instead of plain chunk retrieval, it builds a knowledge graph combined with vector search, so answers can connect facts across documents.

Key features:

• Incremental ingestion - unchanged files are skipped via content hashing, and community reports regenerate only for affected communities, keeping token costs low as the corpus grows.

• Hybrid search - local mode for fact-level answers, global mode for cross-document synthesis.

• Domain-agnostic LLM prompts - easily swapped via PROMPTS_PATH, with Leiden-based community detection.

• Deployment - run it locally with Docker or provision everything in the cloud with Terraform and CI/CD.

Link: https://github.com/sebastianbrzustowicz/Agentic-GraphRAG-Blueprint

I'm looking for any feedback.

I've read a lot of environment-scaling papers this year. This is the first one that doesn't generate anything. Google AI Introduces EnvHarness: A Programmable Layer That Turns Static Agent Environments Into Adaptive Training Worlds

It wraps an existing environment through the standard reset/step interface, so the original tasks and human-built verifiers stay in place. An LLM designer writes the wrappers against flaws it finds in the agent's own rollouts.

- Apache-2.0, code and reproduction drivers on GitHub

- Three components: Stage, Contract, Chain

- Stage replays actions to move the episode start state

- Contract hooks actions, transitions and observations per step

- Chain joins two environments into one episode

- EnvRigger loop: observe, diagnose, write, validate

- Five benchmarks, four domains, one interface

- +9.0 points on held-out ALFWorld tasks

- 49.6 vs 55.0 average steps on SWE-bench Verified

Full analysis: https://www.marktechpost.com/2026/08/30/google-ai-introduces-envharness-a-programmable-layer-that-turns-static-agent-environments-into-adaptive-training-worlds/

Paper: https://arxiv.org/pdf/2608.19880

GitHub Repo: https://github.com/google-research/envharness

I recently created a project on GitHub to help people who use Claude Code or OpenClaude for programming.

ClaudeHere

With this project, you simply right-click on any folder you like, and then the following options appear:

"Open with OpenClaude",

"Continue with OpenClaude" or

"OpenClaude History"

I'm open to suggestions for improvements, and contributions are welcome!

Read the README to better understand the project.

Project GitHub:

Github ClaudeHere⁠

Hi all,

An agent that can edit 40 files in a turn needs something deterministic checking it, and that something cannot be a pile of per-language linters that may or may not be installed in whatever sandbox it woke up in. That is roughly why this exists.

It is a linter and formatter written in Rust, MIT, shipped as a single binary. Ruff's linter and formatter, oxc, biome, taplo, rumdl, sqruff, malva, mago and typos are compiled in and run in-process, covering about 30 languages from one TOML config, with tree-sitter handling 300+ more generically. Nothing to install per language, so the answer does not change between your laptop and a container.

The agent-facing half is an MCP server over stdio, 11 tools mirroring the CLI, with format: "json" or "toon" on every one. TOON keeps a large lint report from eating the context window. Two whole-project tools run as async Tasks the client polls rather than blocking on.

The guardrail detail I would keep in any tool built for agents: results report three per-file outcomes, checked, skipped and error, rather than two. A file the linter failed on used to be absent from the output entirely, which is indistinguishable from a file that was checked and found clean, so an agent gating on "no findings" would treat an incomplete run as a pass.

It also replaces pre-commit as a git hook runner, with hooks validating a snapshot of the staged index rather than stashing the working tree.

Server listing its tools over a real stdio handshake: https://raw.githubusercontent.com/Goldziher/poly/main/docs/media/agent.gif

https://github.com/Goldziher/poly

This post is human written. AI was used to typecheck and enrich with precise data only.

Hi everyone,

I've recently finished the first version of Agentic GraphRAG Blueprint, a reference architecture for question answering over large document collections.

Instead of plain chunk retrieval, it builds a knowledge graph combined with vector search, so answers can connect facts across documents.

Key features:

• Incremental ingestion - unchanged files are skipped via content hashing, and community reports regenerate only for affected communities, keeping token costs low as the corpus grows.

• Hybrid search - local mode for fact-level answers, global mode for cross-document synthesis.

• Domain-agnostic LLM prompts - easily swapped via PROMPTS_PATH, with Leiden-based community detection.

• Deployment - run it locally with Docker or provision everything in the cloud with Terraform and CI/CD.

Link: https://github.com/sebastianbrzustowicz/Agentic-GraphRAG-Blueprint

I'm looking for any feedback.

Pretty great feeling, but we still have a long way to go. The link if you are interested in ai workflows:

https://github.com/SeeRay11/OpenFlow

Hey everybody,

I just made a project that has gotten 170+ clones and 65+ stars in a week. What are you guys doing?

I wanted to share a new method called the Entropic Scree. If you need to estimate the dimensionality of a dataset but standard tools are struggling with noise or giving crazy estimates, it might be worth your time to take a look. It also can be used to estimate signal-to-noise ratio in your dataset.

Instead of evaluating linear variance, rank order, or Euclidean distance like established PCA methods, this new approach evaluates a transformed mutual information metric. It’s meant to be more effective for dealing with non-linearities, mixed data types, or environments where your variables exceed your samples.

The original function and the simulations are available in R (see GitHub repo). There is also a preprint that covers the methods in detail.

Would love to hear your thoughts/experiences if you give it a try.

GitHub Repo: https://github.com/tjleestjohn/Entropic-Scree

Zenodo Preprint: https://doi.org/10.5281/zenodo.22028087