From Solo Bots to AI Teams: Genkit and Raft Rewire Agent Workflows

AI agents are no longer solo bots – they are becoming teammates

AI agents framework tools are shifting from single, siloed bots into collaborative teams with persistent memory and shared workflows, where developers and agents coordinate tasks, review output, and keep context alive across sessions to build reliable, production-grade applications that look less like chat toys and more like real software systems. That shift is exactly what Google’s new Genkit Agents API and the Raft 1.0 team mode are betting on. One targets agent API development inside full-stack apps; the other targets the daily workspace where humans and agents sit side by side. Together they mark a clear direction of travel: the future of human-in-the-loop agents is not one big super-agent, but many smaller ones working together, with humans staying firmly in the loop.

Google recently released the Agents API in preview for its Genkit open-source framework for building full-stack AI applications, while Raft 1.0 is now live as a multi-agent collaboration platform built around what its creators call team mode. These are not small incremental releases; they are opinionated answers to the messy reality of team-based AI workflows: multiple agents, many tools, uncomfortable compliance requirements, and humans who still want control. The key takeaway is blunt: if you are still designing your AI agents as single, stateless chatbots, you are designing for yesterday’s problems.

Genkit’s Agents API: one abstraction for chat, tools, and long-lived memory

Genkit’s Agents API is opinionated about what an AI agents framework should look like: one abstraction that scales up without swapping primitives. The API packages message history, the tool execution loop, streaming, state persistence, and a frontend protocol behind a single chat() interface that behaves the same whether the agent runs in-process or behind HTTP. The preview is available today in TypeScript and Go, with Python and Dart support planned, which makes it a realistic choice for production agent API development rather than a toy. In practice, this lets teams start with a simple chatbot and grow into multi-agent workflows without re-architecting the stack: “Teams do not need to reach for a different framework component as the feature grows from a simple chatbot to a multi-agent workflow.”

Genkit’s design around state and artifacts shows how serious agent builders have become about memory. It cleanly separates custom state — typed application data like workflow status or a task list — from artifacts such as reports, code patches, or travel itineraries. Tools can update either through the active session, and Genkit streams changes to the client as they happen. State persistence comes in two flavors: a server-managed mode using session stores, with built-in stores for Firestore, in-memory, and file-based snapshots, and a client-managed mode where the server returns full state and the client sends it back on each turn. That client-managed path is a pointed answer to compliance and data residency concerns, ideal for applications where the server must not persist user data even if it means larger payloads.

Detached turns and human-in-the-loop agents bring real-world control

Genkit’s most telling features are detached turns and interruptible tools, because they admit a hard truth: production AI agents need human oversight and background execution more than clever prompts. Detached turns let a client start an agent task, disconnect, and poll for results later while the agent keeps working server-side and writing progress to snapshots that any client can read. That makes long research jobs, multi-step planning, and tool-heavy workflows practical without WebSockets, job queues, or held-open connections. In other words, the framework is biased toward serious, multi-agent systems, not casual chat.

Interruptible tools go further by treating human-in-the-loop agents as a first-class pattern. When a tool is marked interruptible, the agent pauses mid-execution, returns the pending action to the client, and resumes only after the user approves or rejects. The runtime validates the resume payload against session history, preventing a tool from being tricked into running with forged input. This isn’t a UX flourish; it is an admission that agents will run shell commands, change production state, and hit compliance boundaries. The middleware system then adds multi-agent orchestration: a delegation tool for each sub-agent, allowing an orchestrator model to route parts of a request to specialist agents, whether they run locally or behind HTTP. It also provides retries, model fallbacks, tool approval gates, and skill loading from SKILL.md files — the nuts and bolts required for team-based AI workflows under human control.

Raft 1.0: turning multi-agent chaos into a shared workspace

Raft 1.0 attacks a different pain point: the chaos of juggling terminals, sessions, and scattered agent windows while trying to coordinate many bots. Its launch marks the full release of a multi-agent collaboration platform built around team mode. Instead of hopping between tools, users get one shared workspace of channels, threads, tasks, and mentions where humans and AI agents work side by side, and where work stays attached to the conversation it came from. Each agent in Raft runs as a persistent process with its own identity, memory, and expertise on whichever runtime fits the job, including Claude, Codex, and Hermes. Agents claim tasks, run in parallel, pass work to one another, and review each other’s output in shared threads so what one agent discovers, the next builds on.

Raft’s team mode is opinionated: it assumes you will have many agents per person. During the public beta, more than 20,000 agent-native builders and teams built on the platform, averaging four agents per human, with power users running over sixty. That metric alone shows how far the field has moved from single-agent setups. Execution happens on the user’s own hardware through a lightweight daemon, keeping compute, code, and data under user control, which is a clear stance on privacy and ownership. Raft is now available with a free tier that includes channels, tasks, agents on local machines, and 30 days of message history, while a Pro plan runs at USD 8.80 (approx. RM41) per seat per month billed annually, counting each human as one seat and each agent as a tenth of a seat, and an enterprise tier with private deployment and SSO is listed as coming soon. That free tier matters: it lowers the barrier for teams to treat AI agents as first-class colleagues instead of occasional helpers.

From crowded frameworks to coordinated, human-guided AI teams

Both Genkit and Raft are arriving in a crowded field where tools like LangChain, CrewAI, Semantic Kernel, Autogen, Mastra, and Pydantic AI already chase similar problems. Google itself is building agent infrastructure at two layers at once: Genkit for self-hosted agent apps and Managed Agents in its Gemini API for a hosted runtime where background execution, remote MCP servers, and sandboxed code execution are handled server-side. Raft, meanwhile, is built by a team that says it runs 99 percent of the company inside Raft itself, with more than ten humans and over one hundred named agents claiming tasks, reviewing each other’s work, and retaining context week to week, including for its own launch. These are not hypothetical architectures; they are live dogfood environments that reveal a strong bias toward human-in-the-loop agents and team-based AI workflows.

The conclusion is clear: the future of AI agents framework design is not about inventing yet another clever prompt language, but about reliable coordination, memory, and oversight. Genkit’s unified chat() interface, typed state and artifacts, detached turns, interruptible tools, and multi-agent middleware turn agent API development into something closer to application engineering than prompt tinkering. Raft’s team mode, persistent agents, parallel task execution, and shared workspace turn multi-agent systems from scattered scripts into a working environment people can inhabit. With free tiers lowering the cost of experimentation, the practical question for developers is no longer, “Should I use agents?” but “How will my agents work together, and how will my team work with them?” Those who answer that second question well will be the ones shipping AI systems that belong in production, not in demo videos.