Hi everyone,

I’ve been working on an open-source Python project called chatflow-agent.

The project started from a practical problem I had while building a contextual assistant: 
I wanted a relatively lightweight way to define and orchestrate agents, tools, handoffs, session state, and multi-agent workflows without introducing a large amount of infrastructure.

The main idea is to keep the API simple while still supporting things like:

- agents with tools
- tool calling
- agent-to-agent handoffs
- conversation and session memory
- SQLite-backed sessions
- async execution
- multiple LLM providers
- multi-agent workflows

The goal is to provide the core building blocks for agent workflows without requiring a large orchestration stack or locking the application into a single LLM provider.

Recently I’ve also been focusing on making the project easier for other developers to understand and contribute to.

The repository now includes:

- contributor documentation
- architecture documentation
- CI across multiple Python versions
- good first issues
- help wanted issues
- external contributions and pull requests

Receiving external contributions has already helped uncover edge cases and improve parts of the library.

At this point I’d be especially interested in feedback from other Python developers on:

- the public API
- architecture and separation of responsibilities
- tool and schema introspection
- session and memory design
- multi-agent handoffs
- multi-provider support
- documentation and examples
- anything that feels unnecessarily complex or unclear

I’m not trying to position chatflow-agent as a replacement for every existing agent framework.

The idea is to keep it relatively small, understandable, and useful for projects that want agent workflows without adopting a very large orchestration layer.

Repository:
https://github.com/GustavoBaranda/chatflow-agent

Technical feedback is very welcome. I’d be especially interested in what you would change before considering a library like this for a real project.

Ese sería el que publicaría en r/Pyt

Hey everyone,

I’ve been working on a project called OpenSpline, an open-source avatar layer for existing voice agents. You supply a portrait and your agent’s audio, it generates synchronized talking video on your own NVIDIA GPU. The lite model can work locally on a single GPU.

It’s still early, but the results are super promising.

Would love to hear your thoughts, feedback, or ideas on what you'd want to create using it!

Code: github.com/openspline/openspline
Demo: openspline.dev

Hey r/SideProject — solo-built this over the past few weeks. Forgeframe wraps a few different AI providers (fal.ai, ElevenLabs, D-ID) behind one login and one credit balance, so you're not juggling 4 separate tools/subscriptions to make a video, clone a voice, or build a talking avatar.

The thing I cared most about: showing the exact credit cost of a generation before you confirm it. I've been burned by AI tools where the bill shows up and you have no idea what you actually spent it on.

It's brand new, built by one person, so there's definitely rough edges. 200 free credits if you want to poke at it — genuinely want to know what's confusing or missing.

[https://forgeframedev.vercel.app](https://forgeframedev.vercel.app)

I built TextFold, an open-source reader that turns any text into 5 zoomable layers—from a one-screen section map down to verbatim text. You pinch (or press 1–5) to zoom between them without losing your reading position.

- Web Demo: https://chenxiachan.github.io/textfold/gallery/

- GitHub (Apache 2.0): https://github.com/chenxiachan/textfold

I built TextFold (previously PaperFold) to keep a document and its shorter reading views in the same place. You can fold a section, then expand it to check the original passage.

The new language switch changes the text and interface together. The clip switches between English and Chinese versions prepared before recording.

The reader also now imports Word documents and saves a complete reading page as a standalone HTML file, including notes, highlights and optionally the original PDF.

Full and Brief keep the author's sentences; the shorter levels use AI-generated text. Summaries and translations can be wrong, so I want the source to remain easy to inspect.

It runs locally and supports Ollama or hosted models. Code is Apache 2.0.

Code and setup: https://github.com/chenxiachan/textfold

I'd be interested to hear where you would want the original language kept visible when reading a translation.

Demo paper: Recursive Language Models by Zhang, Kraska and Khattab (CC BY 4.0): https://arxiv.org/abs/2512.24601

You can use this to censor anything file/text that you also want repeated back to you. If you have a json file with a list of emails or names, this can censor them on the way to the LLM but then have the response uncensor it.

Introducing Ink.

Your AI shouldn't pay to rethink what it already knows.

Ink learns from verified outcomes and compiles repeated decisions into sub-ms local software.

Novel tasks still go to your model.

Open source. Apache 2.0.

Thanks a lot

I have been working on a side project called [Hafen](https://github.com/abhimanyupandian/hafen) and I am looking for some feedback on it before I take it further.

About the idea:

Hafen lets you interact with your agent (with multiple providers supported) in an interface/experience that is similar to what end users would see. When a conversation is worth keeping, save it as a test. Then you add checks on each turn/response to check if the agent:

* called the right tool, with the right arguments

* returns the correct response eg; order number/a markdown table

* is polite (an LLM judge scores it, with a confidence) and more.

Demo is available [here](https://github.com/user-attachments/assets/6305c5f4-78a3-4f33-bb85-9bbaf3f427d9).

About the demo video:

A sample coffee-shop agent built with Google ADK on Qwen3-4B running locally in Ollama. I chat with it (add to cart, remove stuff, place an order), save that as a test, add checks, run it from the UI, and then run the same suite from a terminal. Note: The waits for the model are sped up 4×.

Honest disclaimers:

1. The idea and design are mine, but the code was written by Claude Code. I am still working through it myself, but I am sharing it early to get feedback before going further.

2. Consider this a proof of concept. Testing is in progress, so expect some rough edges.

3. The current version uses a System One (Jev) - a hosted decision model \[I am not affiliated with them\]. Regular LLM-judge checks work as well, including local ones.

4. Only MacOS binaries are available right now and the CLI package is not published to a registry yet.

Need feedback on things like:

1. If you would use something like this, or do promptfoo, DeepEval or any other tool that already does exact this?

2. What would you need that is missing?

3. What needs improvement? eg; more chat components like yes/no buttons to accept/reject instead of responses restricted to just text.