LobeHub

LobeHub: A Chief Agent Operator

• Agents that run continuously — hired, scheduled and reported on, described as staying in charge without staying online.
• Two marketplaces: agents, and a skills marketplace counted in the hundreds of thousands alongside MCP servers.
• Agent groups assembled automatically for a task, working in parallel with iterative improvement.
• White-box memory — structured and editable rather than an opaque store.
• Open-source heritage, with a downloadable desktop version and any model under your own control.

Why Would Agents Need An Operator?

LobeHub's framing is unusually specific: it organises your agents into round-the-clock operation, hiring, scheduling and reporting on your entire AI team, so you stay in charge without staying online.

The word doing the work is operation, and it names a problem that only appears once agents actually work.

A single agent you supervise is a tool. Ten agents running unattended is an operation, and operations need things tools do not: someone deciding what runs, a schedule, a record of what happened, and a way of finding out when something went wrong.

That is a management problem rather than a modelling one, and it is exactly the layer most agent products skip — they make agents easier to create and leave you to work out what happens next.

Its own example is illustrative: five hundred open issues, fifty agents dispatched, and the user went to bed. Whether that is a good idea depends entirely on how reviewable the output is, which is the question the memory design below is trying to answer.

One agent you supervise is a tool. Ten running unattended is an operation, and operations need a schedule, a record, and a way to find out what broke.

White-Box Memory And Editable Context

Among the features under an Evolve heading sits the most important one: white-box memory, described as structured and editable, alongside personal memory, continual learning and adaptive behaviour.

Editable memory is the feature that makes long-running agents governable, and almost nothing else has it.

The failure mode with persistent memory is specific and infuriating. An agent forms a wrong belief — that you prefer a format you do not, that a project ended when it did not, that a colleague holds a role they left — and then acts on it consistently. Every subsequent output is subtly wrong for a reason you cannot see.

With opaque memory the only remedy is to reset everything and lose what was correct. With structured, editable memory you open it, find the wrong entry and change it.

That difference matters more the longer agents run and the less you watch them, which is precisely the mode this product is built for. Continual learning without inspectable memory is a system that drifts and cannot be corrected.

Skills, MCP Servers And Two Marketplaces

The site displays a skills marketplace counted in the hundreds of thousands and MCP servers counted in the tens of thousands, alongside an agent marketplace and an agent builder that configures names, roles, skills and behaviours from one sentence.

Those numbers deserve reading as listings rather than as capabilities.

Marketplace counts in this category are inflated by the same dynamics everywhere: many entries are variations, many are unmaintained, and a large proportion of any listing directory has never been used by anyone but its author. A community post quoted on the same page cites a different skill figure entirely, which suggests the number moves quickly.

What the count does establish is that the platform bet on MCP early and built around it, and that is the strategically correct bet — a standard interface means agents reach systems nobody wrote a bespoke connector for.

The agent builder taking one sentence and configuring role, skills and behaviour automatically is the more practical feature. The barrier to using agents has never been capability; it has been that configuring one properly takes longer than doing the task. Hosted assistants like Kimi remove that setup entirely, and remove the control along with it.

• Read marketplace counts as listings, not as working capabilities.
• Inspect the memory early and correct wrong entries before they compound.
• Start with one scheduled agent, not fifty.
• Check where your model keys and data actually sit.
• Route reports into a channel someone reads.

Agent Groups And Parallel Work

Under a Collaborate heading the site describes agent groups working as real teammates, with automatic team formation, parallel collaboration, multi-task execution and iterative improvement, alongside Pages written by multiple agents sharing context, plus projects, schedules and a shared workspace.

Multi-agent collaboration is the least proven idea in this field, and it is worth separating the plausible part from the speculative.

The plausible part is parallelism on separable work. Fifty independent issues genuinely can be worked in parallel, because nothing about issue seven depends on issue twelve. That is a scheduling win and it is real.

The speculative part is agents improving each other's work iteratively. Models are poor judges of quality, including their own, and a group that agrees with itself can converge confidently on something wrong — with more conviction than a single agent would have managed.

The shared context in Pages is the mitigating design. Agents working from one visible document rather than passing messages means you can read what they collectively believe, which is the only practical way to supervise a group at all. Evaluating what a group actually produced is a separate discipline, and Promptfoo's.

From Open Source Chat Interface To Platform

The community quotes on the page tell the product's history plainly: an open source ChatGPT interface, a universal LLM web UI, one-click installable on any local machine, with tens of thousands of stars on a public repository.

That heritage is worth weighing alongside the new positioning, because the two serve different people.

The original proposition was control — run any model, keep your keys, host it yourself, own the interface. That audience cares about independence, and it is why the project accumulated the following it did.

The Chief Agent Operator positioning is a hosted, managed proposition. Agents running around the clock in the cloud with reports arriving in Slack is not something you run on a laptop, and the two versions of the product pull in opposite directions.

The site still offers a desktop download and states any model under your control, so both appear to be available. Anyone choosing it for the original reason should verify how much of the new capability survives self-hosting, because that is exactly the sort of thing that quietly becomes cloud-only — the same tension Khoj navigates between its hosted and self-hosted versions.

Running Agents Without Staying Online

The step from using an agent to operating a fleet is where people either get real leverage or create a mess nobody can audit.

This sequence builds the oversight before the scale.

1. Establish where models, keys and data sit before connecting anything.
2. Configure one agent for one recurring task and let it run a week.
3. Read its memory and correct anything wrong before adding a second.
4. Route reports somewhere a person actually reads them.
5. Try a group only on work that genuinely separates into parallel parts.
6. Review what ran unattended, weekly, rather than assuming it was fine.

LobeHub: Marketplaces And Scale