How to Successfully Integrate AI in Software Organizations
Strategic organizational structure is paramount to AI integration (and AI transforms the ideal structure)
Coordination is King
Architectural design in software engineering organizations primarily reflects optimizations for coordination.
A microservices architecture, where business automation is distributed across a panoply of systems, is primarily valuable for its organizational convenience.
Just as Adam Smith encouraged specialization to scale an economy, microservices allow specialized teams to form around a slice of business automation.
In theory, this focus will produce better results than if attention is split across multiple domains that compose business automation.
Software engineering leaders often primarily see the impact on technical competence—but they are not the ones at the helm of the company.
Those in charge at the highest level care most about what optimizes for coordination rather than technical competence.
Microservices allow for distributed teams that can coordinate effectively, increasing output.
High-performing technologies companies—think Stripe, Meta, Google—become the organizational models for the rest of the field.
Even if smaller organizations don’t have the opportunity to scale resources through specialized, distributed teams, they still adopt microservices.
With AI, team structures are no longer the paramount factor for coordination.
Let me explain by applying this insight to software engineering organizations.
Reimagining Software Team Topologies for AI Integration

Summary of the Team Topologies Schema
I found Team Topologies (summarized above) to be the gold standard for organization software engineering organizations.
“Stream” teams make contributions to a standalone slice. A slice could be the entire software application when smaller in scope, or a microservice for larger organizations/products.
“Enabling” teams are used like calvary, being marshalled to help perform a transformation across stream teams—such as when performing rebranding across disparate applications/experiences.
“Platform” teams may maintain central systems and/or expose provide accessible tools that speed up the output of stream teams.
An example of a “complicated-subsystem” team would be a central, legacy billing system that processes invoicing requests from a plethora of products.
If team structures are no longer the paramount factor for coordination, then how would even the purest software engineering organization be reorganized in light of pervading difficulties with AI integration?
Reimagining Platform Teams
The dawn of agents removes the need for platform teams.
Recall, platform teams centralized best practices for delivery via systems/tools, but those best practices can now be uniformly applied to all stream teams via a markdown file (skill).
Platform teams, then, are primarily in place to integrate best practices into agents at the stream level.
For example, a platform team responsible for CI/CD would remove any machinery (central systems and tools) they’ve introduced to optimize deployments.
Instead, they act as an enabling team in the short-term to ensure every stream team gets a skill plus a dedicated resource to delivery seamlessly with best practices. Afterward, the team could become a new stream team or mixed into existing ones.
A supervisor can absorb observing delivery metrics.
Reporting value is much simplified. Value is derived by comparing a stream team’s cost (agents + dedicated resource) against output.
Reimagining Complicated-Subsystem Teams
Similarly, there is no reason for complicated-subsystems.
If the complexity is due to the technical details, deploy enabling teams as needed to transform.
If the complexity is due to coordination issues with a central system, then a similar path as platform teams may be taken.
After transformation, the team is a stream team.
Reimagining Stream Teams
Stream teams are the most effective because their work is direct and their impact easily observable.
Each stream should have one agent per team member, and one dedicated resource for delivery.
Since an agent can birth its own organization in a sort “sub-frontier” connected to an “author” (team member) to handle complex tasks, the pinning of a single agent to a single engineer is essential to have traceable costs.
Agent organizations should never “float” as an entity outside of a stream team.
The software engineering organization should consolidate on an agent and agent harness.
Moreover, there should be no harness engineering/optimizing in the beginning.
AI integration requires traceable costs within a lean structure. Seamless integration is worth any premiums accrued when resisting optimization.
Even after the initial integration, the organization should lean on the side of simplicity as models continue to absorb the capabilities of platforms and tools.
Reimagining Enabling Teams
Enabling teams increase in value with AI integration.
As the AI ecosystem rapidly evolves, there should be plenty of opportunities for enabling teams to perform transformations across the stream teams, especially since platform and complicated-subsystem tasks become one-time transformations—as outlined above.
Enabling teams could also be dual-purpose to perform short-term technical and product experiments to iterate further after a first-pass AI integration phase.
I’m undecided whether enabling teams should be a deployable pool or divided up and assigned to stream teams. In either case, it makes sense of both stream and enabling teams to have a distinct supervisor as they provide value in different ways.
Further Transformation
After performing the transformation suggested above, only stream and enabling teams remain, yet no engineers are lost as they are merely redistributed into stream or enabling teams.
It does raise the question, however, as to whether both stream and enabling teams can further reduced to just one agent and worker per team (or, at least, a smaller team than pre-AI integration).
The blunt answer: probably.
But that’s an ethical question that the organization (and its transformation) is subservient to.
Oversight
There could still be some room for centralization, but I presume it would be a thin pattern of automated feedback and maintenance of skills—as Will Larson has recently documented.
My assumption is that this does not require a dedicated platform team.
Guiding Principles
Optimize for efficient delivery and reporting
Consolidate on a single platform for agents and agent harnesses
Keep the AI architecture minimalist—avoid initial cost optimizations that obscure reporting
Remove centralization to increase direct contributions enabled by micro transformations (stream and enabling teams)
With simplified structures, use plain-English reports to curate data instead of any “machinery”


Discussion about this post