AI as the running core of the company.
I believe every role in a company will soon operate through a personal agent. Those agents will collaborate with each other and with a shared AI core to execute most day-to-day work. Humans shift from doing to reviewing, intervening only when the system produces an outcome that needs human judgement.
Topology: seven role nodes delegate to personal agents, which feed into a shared AI core. Agents coordinate over a shared issue tracker and chat platform — the same way human teams do today. Humans remain in the loop as reviewers, setting principles and intervening on exceptions.
Six principles
I believe the personal agent will become the most important tool in a professional’s toolkit — more important than the IDE, the spreadsheet, or the CRM. Each role — PM, engineer, designer, DevOps, SRE, marketing, sales — will operate its own agent that understands the domain, knows the team’s conventions, and can act autonomously on delegated tasks. In my view, this is not a distant future; it is a near-term configuration problem, not a research problem.
What I expect to see is that agents adopt the communication infrastructure humans already use — issue trackers, chat platforms, review tools — rather than requiring bespoke agent-to-agent protocols. A PM agent opens a ticket; a developer agent picks it up, writes the code, and opens a pull request; a DevOps agent runs the pipeline. The interfaces are already there. The agents simply need to be wired into them. I think this matters because it means the transition is gradual and auditable, not a hard cut-over.
In my view, the shift is not humans versus agents — it is humans moving one level up the abstraction stack. Agents handle execution; humans handle judgement. A human sets the goal, reviews the outcome, and intervenes when the result falls outside acceptable bounds. The cadence of human intervention shrinks over time as agents become more reliable, but the human remains the final authority on what “correct” means. I believe this is the model that actually scales: not replacing people, but changing what the job is.
I expect the agent to carry the accumulated knowledge of its role — the same implicit knowledge a senior employee carries — and use it to negotiate with peer agents on behalf of its human. A designer agent knows what “accessible” means in practice. An SRE agent knows the team’s on-call runbooks. A sales agent knows the pipeline stage definitions. What makes this powerful is that those agents can then negotiate a solution across role boundaries without a human mediating every handoff.
I believe the right mental model is not “give the agent a task” but “give the agent a constitution.” Humans define the policies — what quality means, what the acceptable risk envelope is, what the brand voice sounds like — and then let agents operate within those guardrails at speed. When inter-agent collaboration produces an outcome that violates a principle, the human adjusts the constitution, not the outcome. In my view, this is the governance model that makes large-scale agent deployment safe.
What I expect to see optimised for is not cost reduction per se, but the combination of low latency and low error rate — the same SLOs we already apply to production services. An agent that takes two seconds to open a pull request and gets it right 99% of the time is genuinely transformative; one that is slow or unreliable is just another tool. I believe the industry will converge on treating agent execution quality as a first-class engineering metric, measured and improved the same way we measure p99 latency today.