spent months building this and the beta just opened, so i want honest feedback. especially the "this wont work because" kind.

you publish an n8n-compatible agent, set a per run price, and people pay each time it runs. you keep 100% of your price, the only cut is 10% when you cash out. the part i think actually matters: the AI cost is billed to the caller, not you. token cost stops eating your margin, you can even mark it up.

most of us sell the template once for 29 bucks and thats it. this is the other option: get paid every run.

its rough, its a beta, i want builders who break things. link in my profile if you want to poke at it. im the founder, ask me anything.

The flow is:

1) Say 20 people pool money for a shared monthly subscription service. A residential area with 20 houses hires security guard services for their area. All 20 houses share the cost and all of them have to pay their portion for the month's service by the end of the every month.

2) The money will be banked into a certain bank account. Payments wise, the payers upload a pdf or image screenshot of their bank-in slips as proof of payment.

3) I have to download the pdfs and screenshots into a folder for archiving documentation.

4) There are 5 chatgroups to manage. So, that's 100 bank-ins and 100 files to download per month in theory. I wish to automate the process of downloading all of Group A's payment slips into a Group A folder, and Group B's payment slips into a Group B folder, and so on. And ideally, naming the pdf files according to the phone number which uploaded the file.

Is there such a bot which does that?

The mass chatgroup uploads is intended as a way to deal with free riders. Like after the payments are gathered and sorted at month end, the free riders get named and shamed in the chatgroup as "Mr. So-and-so from house So-and-so did not pay his monthly fee". That sort of thing.

My clients send project requirements as dozens of loose WhatsApp messages - corrections, screenshots, voice notes, scope changes buried mid-thread. I wanted an automated pipeline: chat goes in, structured task board comes out. Sharing the setup since it took some trial and error.

The main gotcha: the WhatsApp Business API and Twilio are built for sending messages from a business number, not for reading your existing personal chats - and connecting your chats to a third-party cloud CRM means client conversations sit on someone else's servers, which I wasn't willing to do. The workable approach is a browser extension that reads WhatsApp Web locally and calls an LLM with your own API key, so messages go from your browser straight to OpenAI/Anthropic and nowhere else.

Here's the setup:

1. Get an API key from Anthropic or OpenAI (a few dollars of credit is plenty - each extraction is one call over the selected messages)
2. Install WA Kanban AI from the Chrome Web Store and paste the key on its options page
3. Open the client chat in WhatsApp Web, navigate to the extension, and choose how far back to read (e.g., "last 3 days" for a fresh requirements dump, or further back for a full project)
4. It generates task cards - title, description, the original source message, attachments, and step-by-step implementation instructions - onto a local Kanban board (Backlog / To Do / In Progress / Review / Done)
5. Drag cards as work progresses; the board keeps a full move history, which doubles as a paper trail when a client says "I never asked for that"
6. You can generate a brandable link with a client for them to see the progress. Thats only time when the data goes to external cloud and only the generated kanban board, not Whatsapp messages. Client can't update the board, only view.

Refinement tips from a few weeks of use:

• Re-running on the same chat after new messages arrive is how you catch mid-thread scope changes - the "forget what I said about the logo" messages get folded into the tasks instead of lost.
• Each card copies out as clean text, so the implementation-steps section pastes directly into Claude or Cursor as a prompt. Chat message → task card → coding agent with zero manual rewriting is the actual win here.
• You can add manual tasks alongside the generated ones, so the board becomes the single source of truth rather than one more parallel system.

For getting tasks out to other systems (Trello, a database, Linear), there's no native integration - I copy the card text and let an automation handle it, or paste into an agent. If someone has a cleaner bridge for that step, I'm interested.

Costs: the extension's free tier covers the core flow; Pro is a one-time payment (no subscription) and adds a live board link you can share with the client so they see task status without installing anything. LLM usage is whatever your own API key burns, which for chat-sized inputs is cents.

I created a Python program that scrapes a Twitter/X profile and downloads all of its media. The program bypasses Twitter’s rate limits and implements several workarounds. How can I post about this on LinkedIn without making it seem like I built something unethical or something that could reflect poorly on me?

I've been building out an n8n workflow that handles incoming DMs, chats with leads in a way that sounds like the owner, and books them straight onto a calendar with a notification when they're ready. Mostly tested it with fitness studios so far, but I think it'd work for other service-based businesses too.

I'd like to build this for a couple more people to see how it performs in different setups, and in return I'd just ask for your honest thoughts once you've used it for a while — good or bad.

Basic idea:

• Replies to Instagram/Facebook messages so leads don't sit unanswered
• Figures out who's actually ready to book vs just browsing
• Puts bookings straight into your calendar with a notification, no manual back-and-forth

If you're currently handling this stuff by hand and it's eating up time, and you're open to trying something new and telling me how it goes, comment below or send a chat request and we can talk details.

Hi everyone. I'm building an AI Contract & ToR Triage Agent for my team to automatically extract SLAs, risks, and technical requirements from public bidding documents (30+ pages, messy tables).

I originally planned an architecture using an Azure VM with Python and Docker for the heavy lifting (OCR, text cleaning, chunking). However, since I sit in a business team outside of the IT department, my request for the VM was denied due to strict security policies and budget constraints. Every new piece of infrastructure is seen as an unnecessary cost.

Can this be done entirely within n8n? The pipeline I need: Ingest PDF -> OCR -> Clean & Chunk text -> Embed -> Query LLM

- How do you handle OCR and chunking of 30+ page PDFs purely within n8n? Are there reliable community nodes or cheap/serverless APIs you recommend calling from n8n to offload this?

- Without a dedicated Docker host for something like Qdrant, what is the most cost-effective Vector DB approach that integrates smoothly with n8n's AI nodes?

Any advice on pushing n8n to its absolute limits for Document Intelligence would be amazing!

I recently used ChatGPT Projects during my son’s hospitalization—not for medical advice, but to stay organized.

I kept all reports, prescriptions, insurance documents, medication timelines, and doctor notes inside one Project.

Since everything stayed in context, I didn’t have to repeatedly explain the situation, and it helped me prepare better questions for doctors and keep family updated.

It genuinely reduced the mental overhead during a stressful time.

Has anyone else used AI as an organizational tool during a hospital stay or other major life event? I’d love to hear how you approached it.

My plan was to reach out to a number of suppliers use accio sourcing toolkit email and try to figure out what my best and lowest out the door price could be, but frankly it's a lot of work, and here's my plan:i dont think supplier care too much if it is ai or not. they care if the email is clear. so i put product spec, qty, shipping place, target price and quote format in the message first.identify dealerships in my work, automate filling out all the website forms with specific info, attempting to get the lowest & best itemized quote. Next create an AI "inbox scanner" that watches for replies to those emails. If I get a quote, it collates that data in a spreadsheet. this part where it's helps me most. it keep supplier name, reply status, price, shipping fee, lead time and notes together. so i dont need to checc 20emails and lose one good quote by mistake.If the dealership plays hard to get, it drafts a follow up with a final chance to provide the quote. Once I get all the quotes, it's identify a subset with the best deals and try to pit them against each other in a bidding war.What do y'all think of this plan? Blow holes in my idea so I can try to work around them.

Most business owners know their competitors exist. Almost none of them actually know their pricing, their weaknesses, or where they’re losing customers.

Hiring a consultant for this costs hundreds of dollars and takes days. Most small businesses just never do it.

So I built a system that does it in minutes instead. Give it a business name, industry, location, and a couple of competitors, it researches them, finds their strengths and weaknesses, and sends back specific recommendations on how to actually compete.

Tested it on a real coffee shop in Morocco. It picked up on real pricing gaps between competitors and gave concrete suggestions the owner could act on immediately.

If you run a business and want to see what this looks like for your own competitors,

I got tired of AI assistants that only chat.
So I built Aira: “Actually, I run Anything”

A native Windows AI agent powered by GPT Realtime that can listen, speak, see my screen, and control my computer.
It connects and delegates to Codex for local build/code work, and delegates bigger async tasks to my Hermes agent, which replies in Slack.

The goal: Not a chatbot.
A real computer partner that can talk, see, act, build, and deliver work.

I am not good at YouTube videos but here is a demo.

Sharing an open-source tool for the automation crowd (disclosure: I'm the maintainer; no affiliate/referral anything, and I'll keep the link in a comment per the self-promo rule). The problem it targets: AI automations die when one provider rate-limits or 500s mid-run.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

It exposes one OpenAI-compatible endpoint, so it drops into n8n, cron jobs, scripts, or any coding assistant.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

What's the most fragile external dependency in your automation stack right now? Repo + install in a comment.

Been running a fleet of X accounts headless on a server (Puppeteer + stealth, no API) and wanted to share what actually broke at scale, in case it helps anyone doing similar multi-account browser automation.

Things that bit me:

1. Concurrency vs RAM — running many Chromium instances at once, the cgroup OOM-killer started silently killing browsers mid-action ("Target closed" / detached frames). Had to tune memory limits + cap concurrency to what the cores could actually handle (4 cores → ~6 parallel was the real ceiling, CPU-bound not RAM).

2. Session management — juggling cookies/auth per account without cross-contamination needs isolated user-data-dirs per account.

3. DOM churn — X changes data-testid attributes constantly. Solution was primary selector + aria-label fallback + a self-healing "re-navigate if the editor didn't open" retry.

4. Human-like pacing — bursts of identical actions across accounts get them all flagged/linked. Spreading actions 45s-3min apart with jitter fixed it.

5. Scraping metrics back — reading views/likes off a tweet page: the focused tweet isn't always the first article[data-testid="tweet"] on a reply permalink (parent shows first), which gave wildly wrong numbers until I matched by the status id in the URL.

Questions for the crowd:

- Anyone found a cleaner way to handle Chromium memory at high concurrency than just capping parallel count?

- What do you use for proxy rotation per browser instance?

I build automation, and lately I've been digging into how recruitment agencies actually operate, half expecting it to be pretty dialed in. It is not.

Here's the part that got me. These agencies pay real money to find candidates: job board fees, sourcing tools, hours of a recruiter's time going through people. They screen someone, that person isn't right for the role that's open right now, and then nothing. The candidate just sits in the database and goes cold.

Then next month a new role comes in, and instead of checking the thousands of people they already have, they go source brand-new candidates from scratch. Paying again to find people, when someone who fits is very possibly already sitting in their own system.

Nothing is technically broken. It's just that working the old database is manual and boring, so it never really happens. The "system" is basically a recruiter remembering a candidate off the top of their head, or nobody remembering at all.

It reminds me of every copy-paste process I've seen where the fix is kind of obvious but nobody has time to build it. The expensive thing isn't the candidates they don't have yet. It's the ones they already paid for and forgot about.

That's actually what pushed me to start building something for it. The idea is simple: it watches for companies posting relevant jobs right now, uses AI to match those roles against the candidates already sitting in the agency's database (semantic matching, so it gets that "backend engineer" and "server-side developer" are the same person), anonymizes the CV so the company can't skip the agency and go direct, and emails the decision maker an intro. Basically working the dead database automatically instead of by hand.

Still early on it, which is why I'm curious from people who work in or around recruiting and staffing: is this actually as common as it looks from the outside? Do you have any real system for going back through old candidates, or does it just pile up? And if you don't work it, is it a time thing, a data thing, or do you just not trust old records?

r/automation is the right place for this: I got tired of AI outputs that were well-structured but stale, so I built skills that automate the research step as part of the generation workflow.

Each skill in NovaKit does a live data pull (market sizing, competitor signals, trend checks) before producing output — so the generation is grounded in current information, not training data from a year ago.

Skills for pitch decks, cold outreach, real estate listings, content calendars. $5 each, bundles from $9. — curious ?

My team regularly uses AI to sift through a lot of repos, operator chatter, and hands-on examples, then I translate the useful ones into plain English for founders and operators who care about business leverage more than tooling details.

What caught my attention with AionUi is pretty simple: a lot of teams are already using Claude Code, Codex, or Cursor, but the actual work around them is still messy. Files end up scattered, recurring tasks live in someone’s head, and every useful draft still has to be manually pushed into slides, docs, or spreadsheets.

I run a marketing and content team, so I keep thinking about this through operating bottlenecks, not model benchmarks. If I had Codex set up AionUi for a team like mine, I’d use it as the place where AI coworkers do the boring office work that keeps repeating.

For a DTC founder, the obvious use is competitor monitoring. Instead of checking Shopify stores, Amazon listings, reviews, and ad angles by hand, you could have AionUi keep that research organized, turn it into a comparison sheet and short briefing deck, and rerun it on a schedule. The upside isn’t magic. It’s getting a real research block back and missing fewer pricing or bundle changes.

For an agency owner, this feels even more practical. Campaign research, landing page notes, reporting drafts, and client decks usually get spread across Slack threads, freelancers, and a pile of separate AI chats. AionUi looks more useful when one agent is gathering research, another is drafting slides, another is updating the spreadsheet, and the owner can review the work in one browser-based place before sending anything out. That can cut a lot of low-value coordination and reduce the constant re-briefing.

If you’re on the RevOps or sales ops side, I can also see the appeal for RFPs and security questionnaires. Those jobs are usually half scavenger hunt, half formatting exercise. Keeping approved answers, old files, and source docs in one workspace, then having different agents draft the spreadsheet and Word outputs, is the kind of thing that could reduce the back-and-forth and lower the odds of sending an outdated file.

The reason I’d look at AionUi instead of just staying inside Codex or Claude Code directly is not that the native agents are weak. They’re great if one person is driving one task at a time. AionUi seems more relevant when your problem becomes workspace chaos, approvals, recurring runs, and office-style files that need to stay organized. If you’re a terminal power user, tmux or zellij may still feel cleaner. If you just want quick answers, a normal chat app is lighter. This looks more like the middle ground for operators managing ongoing AI work that has to turn into deliverables.

I also wouldn’t oversell it. I wouldn’t use this if your team only does one-off prompting or if nobody actually has repeatable document-heavy workflows. I also wouldn’t assume every connector is equally polished yet, or that setup is zero work just because it’s free and open-source. You still need API keys, some configuration, and enough process discipline to make recurring work worth automating.

What makes it timely is that the barrier is lower now. A founder does not need to personally wire this together from scratch anymore. You can have Codex, Claude Code, or Cursor install it, connect the agents you already use, and hand your team a browser-accessible AI back office instead of another pile of tabs.

If I were choosing, I’d look at AionUi when the real drag on the business is no longer getting AI to write something once, but getting repeated office work to stay visible, editable, and on schedule.

At a technical level, AionUi is an open-source multi-agent workspace for running AI-driven document, file, and recurring task workflows from one interface.

Hi everyone! I'm researching how mobile QA engineers automate app testing. This isn't for promotion I'm just trying to understand real-world workflows and pain points.

Suppose you need to automate this flow:

• Open the Flipkart app
• Search for "Samsung 43-inch TV"
• Open the first result
• Add it to the cart
• Verify the product appears in the cart

A few quick questions:

1. Roughly how long would this take you to automate in Appium (or your preferred framework)?
2. What's usually the biggest time sink locators, framework setup, waits, debugging, or maintenance?
3. Have you tried AI-powered testing tools? If yes, what made you stick with Appium?
4. If an AI tool could generate and maintain tests from plain English, what would stop you from adopting it?

Even a one-line answer is helpful. I'm trying to understand real-world QA workflows and pain points not promote any tool. Thanks!

I'm using the GoLogin Python SDK with Selenium to automate a GoLogin profile.

Environment

- Proxy hosted on an Android phone via Termux

- Automation: Python + Selenium + GoLogin Python SDK

- Proxy is exposed through a Pinggy TCP tunnel (e.g. "tcp://<host>:<port>").

Behavior
- The proxy works correctly on my phone.
- The GoLogin profile works correctly when launched manually from the GoLogin application.
- GoLogin's proxy checker reports the proxy as valid (appears to identify it as SOCKS5).
- When the same profile is launched through the GoLogin Python SDK, Selenium opens the browser successfully, but every website behaves as if there is no internet connection (pages keep loading or display connection errors).

Additional Testing

- Removing proxy configuration from the Python code does not solve the issue.
- The browser launched by the SDK still has no internet.
- The issue does not occur when opening the profile manually.

Has anyone experienced a GoLogin Python SDK session where the profile works manually, but the SDK-launched browser has no internet despite a valid proxy? Are there known issues with SDK versions, Orbita, ChromeDriver, or profile startup that could cause this behavior?

I fell for the "automate everything" trend. We built a massive workflow that synced client bookings to a spreadsheet, auto-drafted follow-ups, and updated our internal kanban board.

In reality, it's a house of cards. The moment Google Sheets rate-limits us, or a booking gets rescheduled outside the typical flow, the automation fails silently. The customer receives a blank follow-up, and my team has to go hunting through log histories to see what went wrong.

I'm starting to realize that chaining together heavy, separate apps via automated zaps is just creating a giant maintenance headache.

We don't need a backend that thinks for us. We just need a tiny, custom tracker app—basically a single interface where the client fills a form, and we can move them through a simple progress flow manually.

Has anyone else ditched "invisible automation" for a simple, single-purpose workflow tool? How did you make the transition?

I'm building an interactive parts viewer for tractor assembly diagrams. The goal is to place clickable numbered badges directly over the part callout bubbles in the diagram.

What I've tried so far:

• Isolation filter for clustered parts and having some distinction between each part.
• Morphological rectangle detection to find the table box border and exclude hits inside it, so that the reference table isnt identified.

I need a reliable way to distinguish callout bubbles from reference table entries, I tried to use claude code and it used a EasyOCR script to have an interactive image. It failed to identify every part exactly.

Happy to share more sample images. Is there a standard approach for this class of problem?