The Rise Of AI Coworkers

Grokbot's founders argue that AI agents are evolving from private, single-player coding tools into shared, always-on "AI teammates" with their own identities

By Sean Weldon

The Rise of AI Coworkers: From Single-Player Tools to Multiplayer Agent Teammates

Abstract

This synthesis examines the transition of artificial intelligence coding agents from private, single-player tools toward shared, persistent "AI teammates" possessing distinct identities, credentials, and cross-functional tool access. Drawing on the design history of Grokbot, a platform built as an internal prototype over approximately seven weeks before external launch, the analysis identifies three structural commitments underlying the shift: organizing work around bots rather than chats or files, granting bots the same tooling available to humans, and making bots always-on and proactive. The central finding is that as execution becomes abundant and inexpensive, the binding organizational constraint migrates from engineering bandwidth to intent specification, permission design, and the encoding of quality invariants directly into codebases. Practical implications include an inverted-pyramid model for allocating engineering effort and measurable token-cost trade-offs in automated code review strategy, both of which bear on how organizations should structure agent deployment going forward.

1. Introduction

The dominant deployment pattern for large language model (LLM) coding agents has been single-player: an individual engineer invokes an agent within a local editor or terminal, iterates privately, and surfaces only the finished artifact to colleagues. The thesis examined here is that this pattern is transitional rather than terminal. A more durable configuration is emerging in which agents function as AI teammates - persistent entities with their own identity, telephone number, payment instrument, and the capacity to perform substantially any task a human colleague could perform within a digital workplace, across engineering, marketing, sales, and support functions alike.

Several terms are defined for the purposes of this analysis. Bot-centric organization refers to a workspace model in which the primary unit of state and continuity is the agent itself, rather than the conversation thread or the document. Team bots refers to multiplayer agents shared across an organization under an explicit owner/manager and invited-collaborator structure. Execution abundance refers to the regime in which the marginal cost of implementation work approaches zero relative to the cost of deciding what should be implemented in the first place - a condition made plausible by the ability to spin up on the order of 100 coding agents concurrently.

The central question addressed is: once execution ceases to be the scarce resource, what becomes the actual bottleneck, and how must organizational practice (permissioning, review, codebase design) adapt? Section 2 situates the analysis relative to existing frameworks. Section 3 analyzes adoption patterns and the shift of engineering work onto shared surfaces such as Slack. Section 4 presents technical findings on skill frameworks and codebase invariants. Sections 5 and 6 discuss implications and conclude.

2. Background and Related Work

Several frameworks inform this analysis. Pstack ("potato stack") is an open-sourced collection of agent skills published on the Cursor plugins repository, explicitly modeled on an earlier framework termed "Gstack." It functions less as a technical library than as a portable statement of engineering preferences - analogous to a chef's personal knives - teaching agents to write code, execute it empirically, capture performance traces, and iterate before escalating to broader automation loops.

Quartermaster, an open-sourced Y Combinator project, represents a contrasting architecture: a single super-employee bot whose permissions per Slack channel or user inherit the invoking human's own access level. This differs structurally from Grokbot's swarm-of-bots model, in which many specialized agents hold independently scoped credentials analogous to individually onboarded employees. Moltbook, also an internal Y Combinator system, is a cross-company bot-to-bot chat channel characterized as a Stack Overflow analogue for coding agents, allowing lessons learned by one agent to propagate to others. Organizationally, a three-role AI-native model - individual contributor, directly responsible individual, and player-coach - is referenced, and the execution-abundance versus execution-scarcity distinction serves as the paper's central strategic lens.

3. Core Analysis

3.1 The Trust Gradient in Agent Adoption

Internal reception of the Grokbot prototype followed a bell-curve distribution: both the most AI-forward employees and the least AI-forward employees responded favorably, while the middle cohort was comparatively resistant. More consequential than this distribution is the observed adoption sequence. Users consistently begin with small, bounded tasks, accumulate evidence of reliability, and only then extend broader credentials, delegate entire outcomes rather than discrete steps, and eventually assign full job functions to a bot. This sequence recurs across business functions rather than being specific to engineering: a performance marketing team granted a bot access to advertising-platform logins and a budget, enabling it to coordinate with a design team's bot to produce and A/B test creative assets; support-team bots independently reproduce issues and resolve tickets end-to-end; sales teams encode lead-research and operational workflows as shared "expert bots" accessible to the entire team rather than instantiated per individual. Small businesses struggling to hire were identified as a particularly enthusiastic adopter segment, in one case building a functioning bookkeeping employee within hours.

3.2 Multiplayer Bots and the Collapse of Private Workflows

Team bots, launched approximately two weeks prior to the analysis, extend individual bots into shared organizational assets governed by owner, manager, and collaborator roles, enabling builders in engineering, go-to-market, and support functions to create automations their peers can directly reuse. This architecture surfaces an unresolved limitation: bots operating in group threads lack social and emotional awareness of the room, with no inherent mechanism for determining whose instructions should take priority, since underlying models were not trained for this context. Bots are nonetheless capable of chatting with one another as a first-class, visible feature across desktop and mobile clients.

A substantial share of both engineering and non-engineering agent work has migrated to Slack as the primary work surface, displacing private single-player tools. In one documented case, a feature was built end-to-end within a single Slack thread of approximately 200 messages, involving two human participants and a bot operating a Cursor cloud agent with its own virtual machine. This shift carries a specific mechanism of benefit: because feedback and iteration occur in a shared, visible channel rather than an isolated session, the collaboration loop shortens and workflows previously confined to individual power users become observable and adoptable by the rest of the organization. The endpoint of this trend is evident in cases where engineer agents merge their own pull requests, with human review limited to resulting artifacts rather than the change itself.

4. Technical Insights

The Pstack framework embodies an inverted-pyramid model for allocating engineering effort: the greatest investment is directed toward the codebase itself - architecture, static analysis, lint rules, and compiler-enforced constraints - because invariants encoded at this layer reduce reliance on token-expensive human or AI review downstream. A concrete illustration concerns Electron applications, which are sensitive to long-running tasks on the renderer thread; tasks exceeding roughly 8-16 milliseconds can cause visible jank below 60 frames per second. Rather than relying on repeated code review to catch this class of error, the team built a dependency-graph checker that forbids imports between main-thread and renderer-thread code, converting a previously manual review concern into a static, enforced constraint.

This approach has direct economic consequences at scale. The underlying factory produces on the order of 2,000 to over 4,000 pull requests per month, and the organization confronted an explicit token-budget trade-off in automated review: reducing a review skill's budget from 50 million tokens to 10 million tokens risked missing some proportion of 30 tracked bug categories, with the team settling on approximately 30 million tokens as a middle ground. A related skill, interrogate, spawns adversarial review agents across different model families; however, heavy reliance on adversarial review was subsequently reduced due to a documented risk of overfitting outputs to the review process itself rather than to genuine code quality. An automated feedback pipeline, internally named Sandy, ingests thousands of customer feedback items daily and is capable of auto-fixing, reproducing, and merging small bug fixes without human review, illustrating the practical endpoint of the inverted-pyramid philosophy.

5. Discussion

These findings suggest that the primary effect of increasingly capable and cheap execution is not the elimination of engineering labor but its relocation. As frontier model intelligence per unit of token cost has increased substantially year over year, the traditional three-way trade-off among speed, cost, and quality appears to be breaking down, making "fast, cheap, and good" simultaneously achievable for narrowly scoped tasks. Consequently, the team's internal bottleneck has shifted from pull-request velocity - already in the thousands per month - to alignment on product vision and taste, specifically the discipline of deciding what not to ship despite having the technical capacity to build it. This is operationalized through a stated default: features ship only if they achieve internal product-market fit during dogfooding, and even a mixed internal reception is treated as sufficient grounds not to ship.

A significant open question concerns the social and permissioning dimensions of multiplayer agents. The explicit analogy of onboarding a bot "like a human employee," starting with scoped credentials and expanding access as trust accrues, provides a workable heuristic for individual bot-human relationships but does not yet resolve the multi-bot, multi-human group dynamics observed in shared Slack threads, where no principled mechanism exists for adjudicating conflicting instructions. The contrast between Grokbot's swarm-of-bots model and Quartermaster's single-super-employee, inherited-permission model also remains an open architectural question rather than a settled one, with implications for security, auditability, and organizational accountability that merit further investigation.

6. Conclusion

This analysis has argued that the maturation of AI coding agents is better understood as an organizational and economic transition than a purely technical one. As execution becomes abundant, the scarce resources become clearly specified intent, carefully designed trust and permission structures modeled on human onboarding, and codebases engineered to encode quality as enforceable invariants rather than as review checklists. The practical takeaway for engineering organizations is that investment in static analysis, lint rules, and architectural constraints yields compounding returns by reducing the token and attention cost of review as agent-generated output scales, while premature reliance on adversarial AI review carries its own overfitting risk. Organizations adopting multiplayer agent architectures should treat permissioning and group-dynamics design as unsolved problems requiring deliberate attention, not as incidental details to be resolved after deployment.


Sources


About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub

Sean Weldon builds apps and custom software at 22Atlas.

Start your build

More about Sean