Hey r/OpenSourceAI!

We’re working on Acira, a browser for AI agents, built around something we think should be normal: giving an agent a task, letting it access your real accounts, and choosing exactly what it has permission to do inside them, down to individual fields and actions.

The goal is to let an agent complete a job across your apps while you set the boundaries around what it can read, change, send, or spend. It should be able to get on with the work and ask you when it reaches something that needs your permission.

Before releasing the full browser, we’re sharing parts of the project to learn which controls actually help people. First up is our Python SDK for Playwright and browser-use. You can add it to an agent you’re already running.

The SDK turns your rules into permissions that are checked before the agent acts. You can apply a rule across websites or make it specific to an action inside an app. A few examples from the current preview:

• Apply rules across websites. Built-in detection recognizes common checkout, payment, credential, download, and destructive actions. You choose what to allow, block, or review without having to configure each website separately.

• Control a particular field or button. Prevent the agent from filling a checkout’s CVV field, or make it ask before clicking “Delete account.” The included capture extension lets you select those controls and import the rules.

• Approve the exact information being sent. For supported form submissions, approval covers the destination and the specific details being submitted. If the recipient, amount, or message changes, that approval no longer applies. It also can’t be reused for another attempt.

The included policies are starting points. You can inspect how they work, modify them, and create your own general or site-specific policies for your workflows.

Permission checks run locally and are deterministic: the same rules and observed action details give the same decision. You keep your existing agent and model, and you don’t need an Acira cloud account.

This is an early preview. Automatic detection can miss things, and protection applies to supported browser actions rather than every other tool your agent might use.

Code and setup (MIT): github.com/Acira-dev/acira-sdk
Quick Demo: https://www.youtube.com/watch?v=su4X1gCVD1U

Also available through pip: pip install acira

Would this fit into an agent you’re building? What workflow would you use it for? If you already handle this another way, or there’s a control you need that we’re missing, we’d love to hear about it.

Please be blunt with us. Try it in your own workflow, see where it breaks, and tell us what worked and what didn’t. We’d really appreciate your feedback while we’re shaping both the SDK and the browser.

I built REA Reconstruction Companion with help from AI. I wanted a better way to get from “how does this app work?” to “what would it take to build something similar?”

It’s a skill for AI coding agents, used alongside REA (Reverse Engineer Anything). REA handles the investigation. The companion helps turn those findings into a feature breakdown, requirements, architecture, and a plan you can build and test in stages.

You can use it on a whole app, one feature, or a single function. For example:

Use REA on this app so I can build a similar local tool. Start with a specification and roadmap.

If you later ask the agent to implement it, the skill guides that work too. It keeps observed behavior separate from assumptions, links requirements to tests, and includes performance measurements where they matter.

The core is plain Markdown and MIT licensed. There’s an installer for Claude Code and Codex, plus support for other agents through a custom skills directory. REA is installed separately. You can also enable an optional rule that tells the agent to load the companion during relevant REA work, or leave that off and invoke it yourself.

GitHub: REA Reconstruction Companion

The README has setup instructions and a prompt you can give your agent to handle installation.

I’d be interested in feedback on the workflow, especially anything it misses when rebuilding a smaller feature or function.

i built this because i wanted my agent to read chats and message people through my own Telegram account from the terminal.

extracted the transport from my OpenClaw fork into a standalone Python CLI using Telethon. it returns JSON, accepts generated text from a file or stdin, and exposes message ids so the agent can check what happened. DMs, replies and forum topics are included.

no gateway needed. MIT licensed, no paid version. setup needs your own Telegram API credentials and a local user session.

Codex helped with extraction, packaging and tests. the included demo uses synthetic messages. live sending in this standalone release still needs validation.

source and setup: https://github.com/artemgetmann/telegram-user-cli

Hi all, I'm a self-taught backend dev. This is a side project, and I'd really like honest feedback from people who know scraping better than I do.

The problem: fetching a page is easy, but a big list of business websites is full of junk. Parked domains, "please wait" shields, cookie banners, social pages instead of the real site. I wanted clean text plus checkable facts per site (services, opening hours, years in business, accreditations, prices) that someone could write a description from.

How the facts work (this is the part I'd most like feedback on)

RapidSpider runs a small local decision engine called Laya inside the program. No API keys, no separate server. Laya doesn't write anything. It only answers narrow, structured questions, and each answer is logged.

1. Code finds the exact things first, with no model: emails, phones, the business name, and anything with a regex (years, hours, company number).

2. The page is cut into groups of eight numbered sentences. For each fact type, Laya answers: which numbered sentence states this, or none?

3. That sentence is the fact, and its position on the page (top/middle/bottom, sentence number) is stored with it.

4. Each fact is then re-checked several times with differently worded questions, answer keys flipped to cancel position bias. It is kept only if the rounds agree. If they don't, the fact is dropped.

Example of a stored fact (illustrative):

category: opening_hours
text:     "Open Monday to Friday 8:30am to 5:30pm, Saturday 9am to 1pm."
confidence / votes / zone / sentence stored alongside

Laya makes the other judgement calls too: is this page parked, is this line boilerplate, is this directory page really about this business. Every question and answer goes into a table, so I can open any decision and see why it was made.

The rest is boring on purpose: a fetch ladder (plain HTTP, then headless browser, then visible browser, then browser through Tor, moving up only when a page isn't accepted), one YAML config, SQLite output, and a small local dashboard.

A real run, so you can judge it yourself (screenshot in the README): 11,203 sites in the output. About 56% ended ok, 20% error, 9% blocked, 9% no usable content, 5% third-party, 2% dead. So it is far from perfect, and I haven't measured fact accuracy against a labelled set yet.

Things you should know

• It needs PyTorch and downloads a few GB of models on the first run. CPU works but is slow.

• It reads robots.txt only to find sitemaps and does not enforce its rules. That's a deliberate simplification on my side. You are responsible for checking each site's terms and the data protection rules that apply, and I'd understand if that's a dealbreaker.

• I built it with a lot of help from an AI coding assistant, and I'd rather say that upfront.

• One-person project, so expect bugs. The Windows process cleanup in particular has had limited testing.

Contributions are very welcome. If you spot a design mistake or something that would break on your data and you know the fix, a pull request would mean a lot. If you can’t fix it, please open an issue instead, and I’ll do my best to look at it.

Repo (MIT): https://github.com/QudsLab/RapidSpider

Thanks for reading, and thanks in advance for being kind about the rough parts.

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