Future ideas: True REPL, First-class multimodal generation, more open-source models, internal MBUS, notebook client, massive parallelism

[iqdoctor]

Future ideas (as brainstorming items):

• Agents as tools massive-parallelism:

• • Release v0.4.13 · evalstate/fast-agent
• • Feature: Agents-as-Tools — expose child agents as callable tools with parallel execution #458
• • my fast-agent testing experience with the **agents_as_tools** high-parallel feature. #520
• • Feat: hybrid Agents-as-Tools/MCP-as-tools experimental agent #515

• True REPL — a Read–Eval–Print Loop inspired by Lisp and Mathematica. Update any prompt, orchestration script, or model on the fly, even during execution. This feature could dramatically speed up development and let multi-agent systems evolve much faster.

• • Release v0.4.22 · evalstate/fast-agent
• • Read the article here: https://github.com/evalstate/fast-agent/blob/main/plan/agentcard-standards-mini-article.md.
• • Sample REPL usage video: https://github.com/strato-space/fast-agent-vertex-rag
• • PR REPL. New AgentCard in md fromat and CLI loading/lazy hot swap with --agent-cards | --watch | --reload options. New workflow-md samples #585
• • AgentCard --watch: minimal incremental refresh (mtime/size, per-card reload, safe parse) #603

• First-class multimodal generation. Right now MCP has to be used to generate images; ideally, multimodal outputs should be native results of prompts.

• • ACP capabilities: src/fast_agent/acp/server/agent_acp_server.py#L305-L404
• • strato-space/media-gen-mcp as multimedia mcp sample

• Extended model list, including exotic providers like GigaChat — for example, LangChain already supports it. Note: GigaChat available as open source platform. @Amigol show me some Cursor gentrated code for this.

• A small internal MBUS — an event/message bus with a publish/subscribe model, allowing agents to be event-activated and fully asynchronous, with an external API.

• A Mathematica-style notebook client.

• Deep chat-bot integration via ACP. See: strato-space/telegram-ai

• Deep web app integration via ACP.

So the direction is: massive parallelism, event-driven activation, openness to novel models, fully asynchronous behavior, and interactive development throughout.

[evalstate]

Yes to all of this :)

True REPL — a Read–Eval–Print Loop inspired by Lisp and Mathematica. Update any prompt, orchestration script, or model on the fly, even during execution. This feature could dramatically speed up development and let multi-agent systems evolve much faster.

It's largely refactoring to do this now; some earlier design decisions now reversed were prohibitive of this. Model switching should now be easy, as well as MCP Server attachment/detachment and in-band context editing. My main thought here is strategically managing the effort. Things exposed as / commands that ACP Client can use are great. Things like context/history editing (like double ESC navigation) which are likely to end up in ACP are probably worth supporting through that channel.

First-class multimodal generation. Right now MCP has to be used to generate images; ideally, multimodal outputs should be native results of prompts.

The current design of fast-agent should make this very straightforward, as the PromptMessageExtended format makes this easy for inputs of docs/images etc:

For native image outputs, I'd imagine we add it as a ContentBlock to the result.

Extended model list, including exotic providers like GigaChat — for example, LangChain already supports it. Note: GigaChat available as open source platform. @Amigol show me some Cursor gentrated code for this.

Main point here is that one of the things sets fast-agent apart is that listed models are comprehensively tested e2e (for multimodal, structured, tool calling, message sequencing etc.). It may be that we draw a visible line somewhere (primarily for support reasons; e.g. 8b models are very useful in fast-agent, but they're not going to make good orchestrators.

A small internal MBUS — an event/message bus with a publish/subscribe model, allowing agents to be event-activated and fully asynchronous, with an external API.

Makes sense, and would make them easier to wire up. I would dearly love to have A2A support and this sounds like a good enabler.

👍

[iqdoctor]

True REPL: #585 REPL. New AgentCard in md fromat and CLI loading/lazy hot swap with --agent-cards | --watch | --reload options. New workflow-md samples #585

[iqdoctor]

True REPL ready: https://github.com/evalstate/fast-agent/releases/tag/v0.4.22
Sample video: https://github.com/strato-space/fast-agent-vertex-rag

[iqdoctor]

Compact hacker plan to hit a moltbot-style growth curve:

1. AgentCard as the distribution unit

• Make AgentCard the single portable artifact (agent + tools + messages + hooks).
• Public AgentCard registry + CLI install (e.g., fast-agent card add NAME).
• Add fast-agent card lint/validate + versioning + signing.

2. Zero-friction integration surface

• Ship a tiny REST API service (fast-agent serve --transport http) + sample FastAPI wrapper.
• SDK snippets: JS/TS, Python, curl.
• One-command quickstart + deploy templates (HF Spaces, Render, Railway, Vercel).

3. Growth loops via ready-made packs

• Curated starter packs (agent bundles + skills + adapters) for top verticals.
• Shareable links for cards (preview + run button).

4. Ecosystem incentives

• Public leaderboard for top cards + badges.
• Bounties for adapters/skills.
• Contributor templates + CI that auto-publishes to registry.

5. REPL + hot swap as killer dev UX

• Make live edit + reload + history preservation rock-solid.
• Demo videos showing instant agent evolution.

6. Targeted integration wins

• IM bots (Telegram/Slack/Discord), webhooks, Zapier/Make, HF, REST.
• Ship reference adapters instead of docs-only.

If we want moltbot-like acceleration, the key is the integration surface + ultra-low friction for sharing. AgentCard is the natural unit of distribution — make it trivial to publish, discover, install, and run.

[iqdoctor]

Extra observations on why Moltbot blew up (based on public writeups/marketing + security analysis) and what to borrow for fast-agent:

Likely growth drivers

1. Ultra‑low friction install (single‑command installer) + instant “it does stuff” demo loop. (see Moltbot install pages)
2. Wide integration surface (WhatsApp/Telegram/Slack/iMessage/Discord + 50+ integrations) and self‑hosted privacy pitch.
3. Marketplace/registry effect (public skills registry; community adds hundreds of skills).
4. Social proof & viral demo clips: short “boring‑magic” automation stories spread fast; huge star velocity compounds curiosity.
5. Drama‑driven awareness (rebrand chaos + security concerns raised visibility; not a strategy, but it amplified attention).
6. Security narratives (both positive and negative) created urgency + discussion — which still fuels discovery.

Actionable moves for fast‑agent (hacker‑compact)

• AgentCard as product unit: publishable, installable, shareable; add registry + card add UX + lints + signing.
• One‑command quickstart: fastest possible “I have a working agent in 60 seconds.”
• Integration breadth first: IM bots + REST + webhooks + Zapier/Make; ship reference adapters not just docs.
• Shareable demos: “before/after” clips of REPL + hot reload + AgentCard swapping.
• Community flywheel: highlight top cards, bounties, CI‑published packs, starter packs by vertical.

Sources / evidence: official Moltbot pages emphasize one‑command install, multi‑platform integrations, and self‑hosted privacy; marketing posts highlight registry/skills counts; security analyses note visibility driven by risk/concerns as popularity rose.

[iqdoctor]

More concrete levers I see from Moltbot’s own materials (these are their public claims, but they point to growth mechanics we can copy):

Observed drivers (from Moltbot docs/marketing)

• Huge integration surface: they explicitly list WhatsApp/Telegram/Discord/Slack/iMessage + 50+ integrations; that’s a distribution multiplier. (moltbot.you)
• Privacy‑first / local‑first pitch: “data never leaves device” + self‑hosted story is front‑and‑center. (moltbot.you)
• Large skill marketplace: 565+ community skills + public registry; strong network effect. (moltbot.you, moltdirectory.com)
• Fast onboarding: quickstart guides emphasize first automation in minutes and simple skill install. (moltbot.you, DigitalOcean guide)
• Model flexibility (Claude/GPT/local) is marketed as a key differentiator. (moltbot.you)

Actions to borrow for fast‑agent (AgentCard‑centric)

• AgentCard as the skill unit + registry: make install/discovery trivial; show counts + categories.
• Integration breadth first: ship official IM adapters + REST + webhooks, with 1‑command deploy templates.
• KISS quickstart: “first working agent in 60 seconds”, then “first skill install” in 1 command.
• Local‑first / privacy story: clear UX + docs to make this a default path.
• Public metrics + social proof: visible counters (cards, installs, integrations) to fuel community growth.

Refs:

• https://moltbot.you/
• https://moltbot.you/why-moltbot.html
• https://moltbot.you/getting-started-with-moltbot.html
• https://moltdirectory.com/
• https://www.digitalocean.com/community/tutorials/moltbot-quickstart-guide

[iqdoctor]

Looked at recent Moltbot docs + a couple reviews. Key adoption drivers seem to be:

1. Messaging-first UX: integrates with WhatsApp/Telegram/Discord/Slack/iMessage etc so users stay in their existing chat apps; gateway makes it always-on. (docs.molt.bot, moltbot.you)
2. Self-hosted + privacy-first positioning; local execution with real automation (shell/browser), not just chat. (moltbot.you)
3. Proactive/always-on agent w/ memory; runs continuously and follows up without re-prompts. (hostinger.com tutorial)
4. Skills/marketplace surface (ClawdHub + 500+ skills) + lots of integrations, so users get value fast. (moltbot.you)
5. Simple onboarding (wizard/installer) + strong narrative/branding.

Fast-agent growth ideas (tie-in to this issue):

• Make AgentCard the distribution unit: public registry + fast-agent install <card|pack>, with versioning + ratings + “verified” badges.
• Ship batteries-included packs that showcase Agents-as-Tools/parallel patterns with 1-command run.
• Build “messaging surfaces” (Slack/Telegram/Discord adapters) or partner with existing ones so agents live where users already chat.
• Emphasize local-first + reproducible runs; guided onboarding + demos that work in <5 min.

Sources:

• https://moltbot.you/
• https://docs.molt.bot/
• https://www.hostinger.com/tutorials/what-is-moltbot