Agency as a Service: The New Architectural Pattern for Agent Orchestration

Author: Engineering Team
Date: January 2026
Status: Beta

The API Integration Governance Problem

If you've managed engineering across multiple product teams, you've seen this pattern: a product manager requests a simple notification—"Can we notify Slack when a high-priority Jira ticket is created?"—and the path of least resistance is a one-off integration.

You wire up a webhook, handle OAuth for a single user, and write 50 lines of glue code. It works, until next week brings a GitHub-to-Jira sync requirement, then a Gmail-to-HubSpot flow. Suddenly, your codebase is a graveyard of unique implementations, each with its own quirks, version drift, and distributed credentials.

This isn't just technical debt. It's a fundamental governance and security problem. Fragmented authentication, audit trail gaps, and an expanding attack surface become the norm. Organizations lose oversight of which agents have access to which data, and security teams are left playing catch-up with every new integration point.

When AI agents enter the mix, the problem compounds. Traditional approaches either burn 150,000+ tokens on documentation just to initialize a session, or require manual tool definitions for every endpoint. Neither approach scales to the hundreds of tools modern teams require.

The industry needs a better pattern: Agency as a Service.

What Anthropic Proved (And How We Build On It)

In November 2024, Anthropic published research that changed the conversation around agent efficiency: Code execution with MCP: Building more efficient agents↗. Their findings validated what many suspected but few had quantified: a 98.7% token reduction—dropping workflows from 150,000 tokens down to 2,000—by representing tools as discoverable code rather than verbose JSON schemas.

The Problem: Context Bloat

Traditional Model Context Protocol (MCP) implementations load all tool definitions upfront. Before the agent even reads your request, 98% of the context window is burned. Furthermore, intermediate results often flow through the model repeatedly—fetching a transcript, processing it, and writing it back to a CRM results in the same data being loaded into context multiple times.

The Solution: Progressive Discovery + Code Execution

Instead of frontloading documentation, we implement Progressive Discovery:

Discover Servers: The agent searches for the relevant service (e.g., jira_cloud_api).
Discover Tools: It queries within that server for specific capabilities (e.g., create_issue).
Discover Usage: It fetches the exact JSON schema for the chosen tool.

Then, the agent writes Python code to orchestrate the calls. Data processing happens in the execution environment (the sandbox), and only the final, filtered result consumes tokens.

Bar chart showing token usage reduction from 150,000 tokens to 2,000 tokens using progressive discovery

Skills as First-Class Citizens: Solving the Composability Problem

Anthropic's research mentions the potential for "wiring up skills," but implementation at scale requires a mechanism for handling response signatures. Standard code execution treats each run as ephemeral—once the code executes, the knowledge of the data's shape is lost.

We have solved this by making skills first-class citizens with automatically mined output schemas.

In-Memory Skill Tracking

Every code execution in our platform is captured as an in-memory skill draft. The system automatically analyzes return values to extract typed schemas:

yaml
outputs:
  key: string          # Jira ticket key
  id: string           # Ticket ID
  status: string       # Current status

This schema is immediately available for subsequent steps in workflow construction. The agent can reference previous executions via in-memory IDs, wiring outputs to inputs with full type validation.

This is the "agent-as-architect" paradigm. The user describes the desired outcome; the agent iteratively builds, tests, and composes the path. This allows agents to track potential skills during long creation journeys, ensuring that complex workflows are built on a foundation of validated components rather than guesswork.

The Paradigm Shift: Who Builds the Workflow?

The automation industry has long been dominated by builders like N8N or Zapier. These platforms require engineers to design the logic and embed AI at specific decision points. We have flipped the script.

Traditional Approach	Agency as a Service
Engineer designs the workflow	Agent designs the architecture
Engineer places AI nodes	Agent decides where reasoning is needed
Focus: Implementation details	Focus: Business outcomes

In our model, the agent is the architect; the engineer is the foreman. You manage the business concerns ("the why"), and the agent manages the technical implementation ("the how"). This separation allows for rapid prototyping and deployment of complex processes that would traditionally take weeks of manual development.

Security: Autonomy Within Boundaries

Anthropic's research on Claude Code sandboxing proved that proper isolation reduces permission prompts by 84% while increasing safety. We implement Boundary-First Architecture: defining security limits upfront so agents can work autonomously within isolated containers.

Failure Isolation: Errors are contained within the sandbox, preventing catastrophic system failures.
Autonomous Recovery: Agents see structured error messages and can self-correct their requests in real-time.
Iterative Hardening: Security ratchets tighter over time based on empirical usage data rather than theoretical restrictions.

For the enterprise, this means centralized governance. You can create dedicated user IDs for agents with scoped permissions—read-only for research, write-only for triage—and maintain a comprehensive audit log of every API interaction.

Known Challenges (Beta)

Even with a strong architecture, there are practical challenges we’ve learned to name explicitly:

Maintaining the agent perspective (tool hierarchy confusion): Agents sometimes confuse top-level MCP tools (discovery, orchestration) with API tools callable inside code execution. The failure mode looks like trying to invoke MCP system tools from within the sandboxed runtime. This is a common “mental model” mismatch as agents scale—especially in long, multi-step workflow builds.
Token and credential lifecycle complexity: OAuth isn’t just “get a token once.” In production you have expiry, refresh, rotation, revocation, and provider-specific quirks. A core value of the hosted platform is taking on that lifecycle burden—centralizing credential storage, refresh behavior, and scoping—so engineers and agents can focus on outcomes instead of hand-rolled token plumbing.

Conclusion: From Integrations to Agency

The industry is moving past the era of fragmented, ad-hoc integrations toward unified agent orchestration platforms. By building on Anthropic's proven efficiency pattern and extending it with first-class composability, we are enabling organizations to deploy autonomous agents that deliver actual business value.

Agency as a Service isn't just about executing code; it's about providing the governance, oversight, and infrastructure needed for agents to build the future of automation.

Get Started: Connect Your First Server

This platform is currently in beta. Access is expanding iteratively as the architecture is refined based on production usage patterns. User feedback directly informs the development roadmap for agentic workflow automation.

Task-Specific AI Agents: Why One-Job AI Outperforms General-Purpose Assistants

Skills: The Building Blocks of Agentic Intelligence