Home Feed Profile


How We Are Building an Agentic Office

TL;DR: Put agents in front of every action. Start with low autonomy; earn more through demonstrated reliability.

In February 2025, I shared a vision: an AI-powered company where intelligent agents sit between every team and their actions, with autonomy increasing gradually as we build trust and capability.

By “agentic office,” I mean agents become the default interface between people and systems, and autonomy is earned incrementally through logging, evals, and guardrails.

Eleven months later, that vision is running in production. Our agents face customers, manage servers, coordinate incidents, and handle thousands of conversations daily.

This is the story of how we got here and where we’re going.

The Original Idea (February 2025)

Back then, code editors and AI assistants were showing us something important: they were just applications built on tool-aware LLMs with a handful of functions. The AI figured out how to use them.

If this worked for code, why not for everything else?

The insight wasn’t simply “put AI in the middle.” It was about creating a path to increasing autonomy. If all interactions between humans and systems go through agents, we get two things:

  1. Immediate benefit: The agent helps with what it can handle today
  2. Visibility into gaps: We safely record what the agent can’t handle, what it escalates, what it gets wrong

This visibility is the key. When every interaction flows through an agent, we know exactly what’s left for that agent to become fully autonomous. We can address gaps systematically, one capability at a time.

┌─────────────┐     ┌─────────────────────┐     ┌────────────┐
│   DevOps    │────▶│   Navid (Sysadmin)  │────▶│  Servers   │
└─────────────┘     └─────────────────────┘     └────────────┘

┌─────────────┐     ┌─────────────────────┐     ┌────────────┐
│  Incidents  │────▶│   Calum (IM)        │────▶│  Response  │
└─────────────┘     └─────────────────────┘     └────────────┘

┌─────────────┐     ┌─────────────────────┐     ┌────────────┐
│  CS Team    │────▶│        Amy          │────▶│  Clients   │
└─────────────┘     └─────────────────────┘     └────────────┘

The Three Components

Every agent consists of three parts:

User Interface: A way to interact with users. Terminal, Slack, web widget, WhatsApp. The medium matters less than having a clear channel.

Functionality: The specific functions the agent can call. For a sysadmin agent, execute_command and ask_user. For a CS agent, get_account_status, search_knowledge_base. The functions define what the agent can actually do.

Comprehensive Prompt: Defines the agent’s role, available tools, and character. This is where you shape how the agent behaves, when it acts versus when it asks for help.

First Agents

(All agent names are internal codenames.)

Navid (Sysadmin Agent) was our first. Two functions: execute_command and ask_user. You tell Navid “the server has slow queries” and it responds “Can I run top -n 1 -b?” Then waits for approval.

Calum (Incident Agent) handles incident management. When things break, Calum coordinates response, tracks status, keeps people informed.

Smith (PM Agent) handles project tracking, status updates, cross-team coordination.

We built agents for security and other internal functions. Each following the same pattern: clear mission, specific tools, human approval for critical actions.

These internal agents validated the approach. But we needed something with real volume and real stakes to see how this scales and to really prove the architecture.

Amy: The Architecture in Practice

Amy is our customer support AI. Today she handles about 4,000 conversations daily with 97% customer satisfaction and 72% autonomous resolution at $0.08 per call. (CSAT measured via post-chat survey; “autonomous resolution” = no human intervention; “per call” = per conversation.)

But the numbers are less interesting than how Amy embodies the Agentic Office architecture. Amy isn’t a single agent. She’s two agents working together, exactly following the pattern we envisioned.

Employee Amy (Client-Facing)

Employee Amy talks to clients. She comes in variants: Client Amy, Partner Amy, API Developer Amy. Each with their own knowledge and focus, but all following the same pattern.

Here’s what makes this different from a typical chatbot: Employee Amy has Slack access. She works like any CS employee would.

When Amy identifies an action she needs to take but doesn’t have access to, she brings it to the relevant Slack channel. She tags CS colleagues for help. She waits for confirmation. Then continues helping the client once the action is confirmed.

Amy (to Client): “I understand you need your affiliate link updated. Let me check with my colleagues.”

Amy (in #cs-affiliate-support): “@cs-team Client CR12345 requests affiliate relink from AFF001 to AFF002. Can someone confirm this is approved?”

CS Agent (in Slack): “Confirmed, processed.”

Amy (to Client): “Good news! Your affiliate link has been updated. Is there anything else I can help with?”

This is exactly the gradual autonomy approach. Amy handles what she can. For what she can’t, she asks colleagues through the same channels any employee would use. Every interaction is recorded: what she handled alone, what she needed help with, what she got wrong.

Manager Amy (Internal-Facing)

Manager Amy lives on Slack and faces internal teams. She has access to:

Operational data: All reports from Employee Amy. What she did, what problems she faced, where she needed help.

System access: The AI definitions, tool configurations, and role specifications that shape how Employee Amy behaves.

Internal team members ask Manager Amy questions on Slack:

“In conversation XXX, why couldn’t Amy answer the client’s question about withdrawal limits?”

Manager Amy evaluates what was missing. Was it a knowledge gap? A missing tool? She proposes how to address it.

“Amy was too pushy in upselling during complaint conversations. Fix this.”

Manager Amy analyzes the role spec, knowledge base, and behavioral guidelines. She proposes enhancements to Employee Amy’s instructions.

As Manager Amy’s capabilities grow, she moves from proposing changes to implementing them. First modifying instructions and knowledge. Eventually modifying the actual tooling code underneath. All with human review and our automated evals (the equivalent of unit tests for LLM applications) between any change and production.

Why This Architecture Matters

This two-agent structure creates the visibility we talked about in February 2025.

Employee Amy records everything: questions she answered, tools she used, times she escalated, cases where clients weren’t satisfied. This is the raw data on what autonomy requires.

Manager Amy processes this data and acts on it. She sees patterns in what’s missing. She proposes and eventually implements improvements. She’s the feedback loop that turns visibility into increased capability.

Human review stays in the loop. Evals validate changes before they go live. But the system itself is continuously identifying gaps and working to close them.

This is different from a static chatbot that you update quarterly. Amy improves herself, within guardrails, based on real interactions.

The Path to Full Autonomy

An agent must never have the option to “guess.” Only act or escalate.

One big factor in the design: the AI needs to know it has only two options. Handle the request or escalate and ask for help. There is no third option where it guesses or fails silently.

And here’s the thing: “ask for help” in the AI era is just a function call available to the agent. The same way Amy can call get_account_status or search_knowledge_base, she can call ask_human_for_help. It’s a tool like any other. (See OpenAI’s guide on function calling if you’re not familiar with the concept.)

This design choice is what makes the gradual autonomy approach safe. Amy never has to pretend she knows something she doesn’t. She either handles it or she asks. Every ask gets recorded. Every record becomes data for improving her capabilities.

Today Amy handles near 75% of all requests and has received her first autonomous write access abilities. But she still escalates questions she doesn’t know or actions she needs to take but doesn’t have a tool for yet. These go to our Slack channels where she tags a human for help, recording the situations for later review. We use these records to continuously increase her coverage and autonomy.

The pattern repeats for each capability:

  1. Amy identifies she needs a capability (visibility)
  2. We implement it with human approval required (safety)
  3. Amy uses it, we observe reliability (data)
  4. If reliable, we reduce human oversight for that specific action (autonomy)

This is how you get from “AI assistant that helps” to “AI colleague that works.” Not by deploying fully autonomous AI and hoping for the best, but by earning autonomy incrementally through demonstrated reliability.

Agent-to-Agent Collaboration

We are working on introducing the next roles now: payment-agents, compliance-agents, growth-agents, and others.

The Amy architecture points to how these will work together. Employee Amy already asks Manager Amy for help. What if payment_ai could ask compliance_ai for guidance? What if growth_ai could consult risk_ai on campaigns?

Payment-AI: “Client CR98765 requesting $15,000 withdrawal to a new bank account in UAE. Account was funded via credit card from UK three months ago.”

Compliance-AI: “Cross-border withdrawal to different country than deposit source requires enhanced verification. Need source of funds documentation and proof of bank account ownership.”

Payment-AI: “Risk-AI, anything else on this account?”

Risk-AI: “Account shows normal trading patterns, no red flags. But the withdrawal amount exceeds net deposits by $4,200. Confirm trading profits are legitimate before processing.”

Payment-AI: “Got it. Request SOF documents from client, verify bank ownership, confirm profit calculation. Flagging for human review before processing.”

Same principle applies. Start with agents that consult each other but require human approval for final actions. Observe what they coordinate well and what they miss. Increase autonomy where they prove reliable.

The Core Principle

The agentic office is about creating a systematic path to autonomy for AI agents.

Route all interactions through agents. They are more than capable of being a middle layer with any degree of autonomy that you are comfortable with. Record what they handle and what they can’t. Address gaps one at a time. Increase autonomy where reliability is demonstrated.

Navid helps manage servers. Calum coordinates incidents. Amy handles customer support with her own internal feedback loop through Manager Amy.

Each started with limited autonomy. Each expands as we understand and address their gaps. This is how we’re building it: visibility into what autonomy requires, and earning it incrementally.

Posted on January 16, 2026

← Next post    ·    Previous post →