[KongchangAI]
· 2 min read· 1,161 words

Aviator: Inside HubSpot's Internal AI Agent Development Framework

Aviator: Inside HubSpot's Internal AI Agent Development Framework

HubSpot's self-built Agent Harness "Aviator" reflects AI Agent competition shifting from models to engineering deployment.

The article introduces Aviator, HubSpot's internal Agent Harness, and analyzes why big companies prefer building their own over adopting open-source Agent frameworks. The core driver is controllability: CRM business demands strict permission control, data isolation, and auditability. It infers Aviator addresses tool-call orchestration and governance, multi-step task reliability (retries, state management, human-in-the-loop breakpoints), and observability and debugging, concluding that Agent competition is shifting from model capability to engineering deployment.

What Is Aviator?

Aviator is an Agent Harness (agent runtime framework) built internally at HubSpot, and it recently sparked a small discussion on Hacker News. Judging by the name, "Aviator" suggests this is not an ordinary AI tool, but an infrastructure layer for steering, orchestrating, and governing AI Agents.

As AI Agents move from proof of concept to production deployment, the core challenge teams face is often not model capability itself, but how to reliably orchestrate Agent behavior, manage tool calls, handle error recovery, and ensure output consistency. Aviator is HubSpot's answer to these engineering problems.

Agent Harness is an infrastructure layer that sits between the underlying large model and the business application above, analogous to a runtime environment or middleware in traditional software. Its job is not to improve the model's own reasoning ability, but to "translate" the model's raw output into controllable, executable, and auditable system behavior. Typical capabilities include: registration and schema definition for tools/functions, the orchestration loop for each model call and tool call (agent loop), context and session state management, error retry and timeout control, permission and quota validation, and complete execution trace recording. Common open-source implementations in the industry include LangChain's AgentExecutor, AutoGPT-style loops, and more recently LangGraph and the OpenAI Agents SDK. Compared with these general-purpose frameworks, enterprise-built Harnesses usually emphasize policy enforcement and observability rather than abstract generality.

Why Are Big Companies Building Their Own Agent Harnesses?

From the outside, more and more tech companies are choosing to build their own Agent runtime frameworks rather than adopting open-source solutions directly. The logic behind this is worth analyzing.

General-purpose Agent frameworks tend to pursue broad compatibility, but in specific business scenarios, this generality becomes a burden. As a leading CRM vendor, HubSpot's business logic involves large amounts of customer data, sales processes, and marketing automation scenarios, with extremely high requirements for Agent permission control, data isolation, and auditability. Building its own Harness means it can deeply customize for these constraints without repeatedly compromising on the abstraction layers of a general-purpose framework.

Another key factor is controllability. When Agents are embedded in core business processes, any unexpected behavior can cause real losses. An internal Harness allows teams to enforce safety policies, rate-limiting rules, and rollback mechanisms at the framework level, which is difficult to achieve by directly calling third-party frameworks.

The Core Problems Aviator Likely Solves

Although public information is limited, starting from the concept of an Agent Harness, it is reasonable to infer that Aviator most likely covers the following engineering challenges.

Orchestration and Governance of Tool Calls

An Agent's capability boundary depends largely on which tools it can call. As a Harness, Aviator very likely takes on the responsibilities of tool registration, permission validation, and call tracing. In enterprise environments, different Agents should have different tool access permissions, which requires fine-grained control at the framework level.

Reliability of Multi-Step Tasks

Complex tasks often require Agents to perform multiple rounds of reasoning and tool calls. Each step may fail, time out, or produce unexpected results. The value of a Harness lies in providing retry strategies, state management, and human-intervention breakpoints, so that the entire process can degrade gracefully rather than crash outright when errors occur.

Checkpoint resumption and idempotency are easily overlooked but crucial engineering issues in multi-step Agent execution. Because each step of an Agent may call external tools (such as writing to the CRM, sending emails, or initiating payments), a simple retry after a mid-process failure can cause duplicate side effects. A mature Harness usually needs to introduce idempotency keys, transactional state snapshots, and checkpoint mechanisms: persist execution state after each critical step, recover from the nearest checkpoint on failure, and ensure that external calls that have already succeeded are not triggered again. In addition, human-in-the-loop breakpoints also depend on this kind of state management—when an Agent encounters a high-risk operation or a low-confidence decision, it pauses and waits for human confirmation before continuing, which requires the framework to freeze and restore the complete execution context.

Observability and Debugging

The "black box" nature of Agents is one of the main obstacles to production deployment. A mature Harness needs to record complete execution traces, including the input and output of each model call, the parameters and results of tool calls, and the decision path. This data is essential for debugging and continuous optimization.

Execution traces are the core data form of Agent observability, usually recording all nested steps in a task in a tree structure: the root node is the user request, and the child nodes are each LLM call, each tool call with its parameters and returns, and the latency and token consumption of each step. The industry is developing standards around this concept, such as OpenTelemetry's GenAI semantic conventions, as well as observability platforms like LangSmith and Arize Phoenix. For enterprise-grade Harnesses, traces are not only debugging tools but also data sources for compliance auditing, cost attribution (counting tokens and call volume by Agent/tenant), and offline evaluation—building regression test sets from real execution traces is a common way to continuously improve Agent stability.

Implications for Developers

The emergence of Aviator reflects a broader trend: the focus of competition in AI Agents is shifting from the model layer to the engineering layer. Model capability is certainly important, but how to reliably integrate Agents into real business is the key to determining deployment success.

For teams building Agent applications, HubSpot's approach offers a reference path—rather than stacking patches on general-purpose frameworks, it is better to design a lightweight, purpose-built Harness based on your own business constraints. This does not mean every team needs to reinvent the wheel from scratch, but at the very least you should clarify your core requirements for Agent governance before deciding on a framework selection strategy.

Although the discussion heat on HN is not high, engineering practice sharing from frontline vendors like this often reveals the real state of industry deployment more than model releases do.

One-line Summary

HubSpot's self-built Agent Harness "Aviator" reflects that AI Agent competition is shifting from the model layer to the engineering deployment layer.

Paragraph Summary

The article introduces Aviator, an Agent Harness (agent runtime framework) built internally at HubSpot, and analyzes why big companies tend to build their own rather than directly adopt open-source Agent frameworks. The core motivation is controllability: CRM business involves large amounts of customer data and sales processes, with extremely high requirements for permission control, data isolation, and auditability, so the abstraction layers of general-purpose frameworks become a burden. The article infers that Aviator most likely covers three major engineering challenges: orchestration and governance of tool calls, reliability of multi-step tasks (retries, state management, human-intervention breakpoints), and observability and debugging. Finally, it points out that the focus of AI Agent competition is shifting from model capability to engineering deployment, and teams should clarify their own governance requirements before deciding on framework selection, rather than blindly stacking patches on general-purpose frameworks.

#Aviator#HubSpot#Agent Harness#AI Agent#Agent framework#observability#tool orchestration
Share:

Related articles