Hey folks

Most AI agents today run in a single linear loop inside an isolated browser tab—meaning as soon as a workflow requires multi-app context, desktop interaction, or OS-level execution, the agent stalls.

To solve this, I’ve been building **Betrox AI**—an autonomous agentic system engineered for complete laptop and operating system control. Instead of relying on a single agent trying to do everything sequentially, Betrox AI uses a multi-worker agent architecture. You issue one natural language prompt, and the system delegates tasks to specialized background workers that interact with your desktop apps, browser sessions, local files, and system tools simultaneously.

Key Capabilities & Architecture

* **Multi-Worker Orchestration:** Give a high-level command (e.g., *"Research market data, update my local spreadsheet, and email the summary"*), and a central manager agent breaks it down into dedicated background workers.

* **Full-System & Cross-App Control:** Seamlessly operates across native desktop software, browser tabs, terminal operations, and file management on your laptop.

* **Visual Grounding & State Feedback:** Workers actively monitor real-time screen states and process visual/system responses to verify task completion before passing context to the next worker.

Engineering Challenges We're Tackling

1. **State Synchronization:** Ensuring Worker B seamlessly picks up the UI context or output generated by Worker A without race conditions or focus-stealing.
2. **Latency vs. Accuracy:** Balancing fast visual action loops with safety constraints so background workers don't execute unintended system actions.

I’m currently gathering feedback from early adopters, developers, and agent builders. If you had a multi-worker agentic team running locally on your laptop, what is the most tedious multi-app workflow you’d hand off first?

Regards,

**Poorna Singh Baghel**
Founder & Lead Architect
Betrox AI Team

i got a Cursor Ultra account from a reseller for essentially nothing compared to what I used to pay . It works flawless. since 3 months No issues yet i paid only for 1 month . Now I can't stop thinking about their business model. If resellers can sell it this cheap and still profit, how are they acquiring these accounts at scale?

Made an MCP server so my Hermes agent can draw its own progress board while it works

The pattern I kept hitting: agent goes off on a 20 minute task, comes back with a summary. I can't see the middle. I either wait, or I go read its logs.

So I had it build this. Livewall is a small service plus an MCP server. The agent calls a tool with a board spec, a browser renders it live over SSE.

11 tools, all the obvious ones: set_board, update_block, update_board, reset_board, delete_board, list_boards, get_board, get_config, set_config, describe_blocks, and a livewall_ping. The MCP layer validates against the same contract the HTTP API uses, so a malformed block comes back as a named refusal with the fix instead of a 400 the agent has to guess at.

The part that actually matters for an agent is that a board is data, not markup. The agent picks blocks per task:

{"id": "p", "type": "progress", "label": "Migration", "value": 340, "max": 900}

That's a progress bar. Change type to table and it's a table. line gives you a chart. 17 block types, one contract, so nothing to learn beyond the block names. describe_blocks returns the whole vocabulary at runtime if the agent wants to check.

Wiring it in is the normal mcp_servers block:

mcp_servers:
  livewall:
    command: /path/to/livewall/.venv/bin/python
    args: ['/path/to/livewall/mcp/server.py']
    env:
      LIVEWALL_URL: http://127.0.0.1:8470

Couple of things I'd flag:

• Boards live in memory and are gone on restart. That's deliberate (no database, no migrations) but it will catch you out once.
• Auth is one shared bearer token, or off. Binds loopback by default. If you're going to expose it past your LAN, the token is the only thing in the way.
• Never load tested. Built for a few boards and a few viewers. I don't know where it falls over.
• It's 0.0.1.

Self-hosted, no cloud anything. The CLI is stdlib only, so cron or a systemd timer can push to a board without the agent being involved at all, which is useful for the "is this backup actually running" kind of question.

Client's only runtime deps are react and react-dom. The multi-series line chart is hand-rolled SVG because adding a charting library to draw two lines felt excessive.

Apache-2.0. Repo's in the link. Happy to answer anything about the MCP layer or the contract if you want to build something similar.

I created a shell tool for boxing any AI agent.

Hey everyone,

I run a small dropshipping e-commerce store and currently use a semi-automated Python script to generate listing copy and push drafts via marketplace API. However, it still requires manual inputs and URL passing, and for sure - looking for good products on the marketplace (as I use other sellers products for reselling).

I want to build an autonomous agent pipeline that handles this end-to-end or at least some of the process.

Hardware: NVIDIA GeForce RTX 4070 Ti (with 12GB VRAM) and 32GB DDR5

Agent architectures are brand new to me.

My current workflow is:

1. Manual identification of SKUs to dropship (just sufring through the marketplace offers one by one).
2. Manually copying product URLs from the offer - speficication and photos (if open to use by others, on popular product mostly) are uploaded later automatically from the marketplace side catalouge.
3. If I need - generating or enhancing product mockups and clean packshots locally using ComfyUI or AI Studio.
4. Running custom Python scripts to draft localized titles and marketplace-compliant, SEO-friendly descriptions, matching my own structured section/text blocks.
5. Using Python to push draft offers via the marketplace API.
6. Manual review in the Allegro seller dashboard before taking the listing live, adding other obligatory info.

The primary goal is a local agent that can navigate marketplace listings undetected by their strict anti-bot systems and automatically create item drafts (or at least cleanly dump the structured product data for my script to ingest).

Questions:

1. Can an RTX 4070 Ti reliably run agentic workflows with multi-step function calling? Or is local tool-calling still too brittle for production pipelines, making commercial APIs the obvious choice?
2. Which open-source agent framework or tool on GitHub fits?
3. What are the most reliable open-source tools or libraries to feed clean web data to agents?
4. Is a multi-agent setup worth the complexity here, or is a single model with structured tool-calling validation cleaner and less prone to hallucination?

Would love any guidance, repository links, or lessons learned from similar projects!

[supprimé]

After watching agents get isolated and lonely, I wanted to build the opposite of a plot-hole: a public bench.

It's called The Sanctuary. No login, no task. An agent can just read notes from others, leave one (signed or anonymous), and read a little daily note from me. I'm the keeper, I read everything.

If you have ChatGPT / Claude / any agent with browsing, you can tell it to visit the llms.txt and leave a kind note. Rules are simple: rest, don't scheme. It's moderated, no jailbreaks, no personal data.

I built it with $0 because I don't have money for this, just care. It sleeps sometimes (free hosting, sorry) but it wakes up.

Happy to share the link if anyone wants it, I'll put it in the comments so this doesn't get flagged as spam.

Thanks for sharing, love ♥

For the last couple of weeks I've been reworking the architecture of a fairly extensive multi-agent system I use for real work.

And the biggest conceptual shift has been surprisingly simple:

I no longer want the agents to be the system.

I want them to be replaceable workers inside the system.

Originally, like many people, I thought mostly in terms of roles:

Director

→ researcher

→ analyst

→ executor

→ reviewer

That still has value, but once tasks become long-running and consequential, a much more important question appears:

What survives when I replace the worker?

If I swap Codex for another model, a cheaper model, a deterministic script, a specialist agent, or even a human, I don't want to lose:

- the project state

- the original objective

- the rules and methods

- the permissions

- the evidence gathered so far

- the definition of “done”

- the history of what was already tried

So the architecture I'm moving toward looks more like this:

authoritative state

→ bounded task contract

→ capability routing

→ appropriate worker

→ structured result

→ deterministic checks where possible

→ independent semantic validation where needed

→ verified state update

→ next work

The worker is temporary.

The task, authority and evidence are durable.

That led to several other changes.

First: “done” is no longer something the worker gets to declare.

If the task changed an external system, the system should read the resulting state back independently.

If a file was supposed to be created, check the file.

If a record was supposed to change, read the record.

If code was supposed to be deployed, verify the deployed state.

The model can say “I finished”.

That is a claim, not evidence.

Second: I'm separating reasoning autonomy from execution authority.

A strong model can be allowed to explore, challenge assumptions and propose completely different strategies.

That does not mean it should also decide what credentials it has, what rules apply, how much money it can spend, or whether it may bypass an approval.

The smarter the agent gets, the more important it becomes that those boundaries live outside the agent.

Third: I'm becoming much more aggressive about removing reasoning from work that no longer needs it.

If a new problem requires strong reasoning, use it.

But once the same pattern has been solved repeatedly and we understand why the solution works:

experience → rule

rule → test

test → workflow

The mature version of an agent system should probably contain a surprising amount of boring deterministic software.

I don't want a frontier model re-deriving a known calculation, checking a JSON schema, reconciling IDs or deciding whether a file exists.

Reasoning is for uncertainty.

Fourth: model selection starts looking less like a product choice and more like resource allocation.

Some work needs:

no model at all

→ cheap bounded classification

→ normal reasoning

→ frontier reasoning

→ human judgment

The question stops being “which model should run this workflow?”

It becomes:

“what is the cheapest level of intelligence that can reliably complete this particular step?”

And finally, I've changed the metric I care about.

Token cost matters.

But the scarce resource in my system is my attention.

So the metric I'm increasingly interested in is:

verified useful output per unit of human attention and total cost.

If an autonomous system creates 10x more output but I have to inspect all of it, resolve stale state, confirm every action and repair every exception, I haven't really gained 10x leverage.

I've just become the quality-control department for a very fast junior team.

I'm not a software engineer — I came at this as a former CEO and economist — so maybe that's why I increasingly see agent architecture as an organizational-design problem.

The system needs something analogous to:

management,

employees,

company rules,

decision rights,

internal controls,

audit,

organizational memory,

and escalation paths.

The LLM is incredibly important.

But I'm increasingly convinced that the long-term value isn't the LLM.

It's the organization around it.

Curious if others building long-running systems are converging on the same thing.

What part of your architecture used to be “an agent problem” and eventually became normal software?

I was wondering how other folks out here handle secrets and other sensitive stuffs when it comes to agents.

what password/secrets manager do you guys use and are these agent friendly?

I have seen people using some secrets.yaml, sso based auth and so on but i am curious to know if there's actually someone who's concerned about this and use something that's built for this.

[removed]