---
type: "post"
id: "box-s-deep-agent-architecture-for-box-agent-657eb5"
slug: "box-s-deep-agent-architecture-for-box-agent-657eb5"
title: ".@Box’s Deep Agent architecture for Box Agent uses a parent/child model."
description: "Box describes how it rebuilt Box Agent around a recursive parent-and-child agent architecture using Deep Agents."
retrieval_nugget: "Box describes how it rebuilt Box Agent around a recursive parent-and-child agent architecture using Deep Agents. The case matters because it turns a familiar enterprise RAG problem into an operational design: defer planning for simple requests, fan out only when work warrants it, and put citations, caching, context control, and inter-agent exchange in middleware."
published_at: "2026-10-27"
updated_at: "2026-10-27"
record_date: "2026-10-27"
date_kind: "published_at"
topics: ["agent-memory"]
entities: ["Box","Box AI","Box Agent","Deep Agents","LangChain"]
related_patterns: ["harness-architecture-outlives-model-choice"]
novelty_label: "new_fact"
what_changed: "Box’s case study adds a new enterprise customer example, describing Box Agent’s parent/child Deep Agents architecture for enterprise content analysis."
prior_refs: ["memory:370d0c5b-372e-84cd-a004-dba08db123e5","memory:bde1e847-1533-84c3-a170-56af4e77d24d"]
source_url: "https://www.langchain.com/blog/building-box-ai-how-an-enterprise-content-platform-went-ai-native-with-deep-agents"
source_urls: ["https://www.langchain.com/blog/building-box-ai-how-an-enterprise-content-platform-went-ai-native-with-deep-agents"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:box-s-deep-agent-architecture-for-box-agent-657eb5"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/box-s-deep-agent-architecture-for-box-agent-657eb5/","markdown":"https://newruntime.com/posts/box-s-deep-agent-architecture-for-box-agent-657eb5.md","json":"https://newruntime.com/posts/box-s-deep-agent-architecture-for-box-agent-657eb5.json"}
---

# .@Box’s Deep Agent architecture for Box Agent uses a parent/child model.

## Retrieval answer

Box describes how it rebuilt Box Agent around a recursive parent-and-child agent architecture using Deep Agents. The case matters because it turns a familiar enterprise RAG problem into an operational design: defer planning for simple requests, fan out only when work warrants it, and put citations, caching, context control, and inter-agent exchange in middleware.

## Summary
Box describes how it rebuilt Box Agent around a recursive parent-and-child agent architecture using Deep Agents. The case matters because it turns a familiar enterprise RAG problem into an operational design: defer planning for simple requests, fan out only when work warrants it, and put citations, caching, context control, and inter-agent exchange in middleware.

## What happened
LangChain published a June 12, 2026 case study on Box AI and the architecture behind Box Agent. Box is an intelligent content-management platform used by more than 100,000 enterprises to store, secure, and govern unstructured data. Its agent searches an enterprise content library, synthesizes findings across thousands of documents, and produces reports and analysis while observing Box's existing security and permissions model.

Box's first agent experience was question answering within one document. It later added Knowledge Hubs, a RAG layer for querying a defined knowledge source. The team found that users wanted broader, more complex work: for example, researchers synthesizing an existing body of work before a study, or a legal team finding contracts over a value threshold from the previous decade and assessing them against a risk rubric. Box evaluated multiple frameworks and says two requirements shaped its selection of Deep Agents: preserving a choice among providers including OpenAI, Anthropic, Google, and others, and avoiding the need to rebuild core agent infrastructure while the team focused on enterprise-specific problems. The company says the model abstraction layer supported provider-agnostic routing and that the open harness enabled a reported threefold improvement in iteration speed.

The current design has a Global Agent as parent. It receives a request, classifies intent, and either handles it itself or spawns child agents. Children are represented as tools to the parent, so calling a keyword search and delegating work to a newly created child share one invocation surface. This replaces an earlier architecture of hardcoded search, QA, and compose agents, which Box says introduced unnecessary latency. A simple question can be answered without a plan. For a complex contract review, the parent makes a plan and can run one child to locate documents, another to retrieve the rubric, and a third to synthesize the completed inputs. Children run with isolated context windows and report through middleware. Their creation, and the tools they receive, is decided at runtime rather than predesigned for each use case.

Both parent and child agents have access to a full tool registry, including BM25 keyword search, vector search, structured question answering over spreadsheets, and file operations. Box chose not to dynamically restrict tools on each request, saying that as use cases expanded, models selected tools better than static routing logic. Middleware intercepts model and tool calls for guardrails, approvals, dynamic context, and application-specific behavior. At Box, it generates citations in parallel with a streamed response, applies prompt caching in multi-turn conversations, and automatically summarizes history once it exceeds 170,000 tokens. It also carries intermediate artifacts: a child can write search results through middleware for the parent or another child to read.

Box reports that its earlier, specialized-agent architecture took about three months to develop and ship. It says the later recursive parent-and-child architecture shipped four times faster, and that the present stack lets the team ship a new agent in a couple of weeks. The company's stated roadmap includes richer agent memory and knowledge composition, but the case study does not specify a delivery date or product commitment for those items.

## What the archive adds
This is a new fact on a known Deep Agents thread. Our earlier Field Note, [Agent work is moving into harnesses, factories, and accepted artifacts](https://newruntime.com/posts/agent-work-is-moving-into-harnesses-factories-and-accepted-artifacts/), described the broader shift toward harnesses and accepted artifacts. Box supplies a concrete enterprise implementation: a parent agent, dynamic children, middleware-mediated artifacts, and measured delivery-speed claims.

## Trend signal
The case supports [Harness architecture outlives model choice](https://newruntime.com/patterns/harness-architecture-outlives-model-choice/). Box explicitly sought provider flexibility while investing its product differentiation in orchestration, tools, permissions-aware content access, middleware, and iteration speed. That is evidence for the pattern's claim that the durable production boundary is the harness rather than the model identity.

## Why it matters
For teams building agents over internal knowledge, the useful lesson is not simply to add subagents. It is to make delegation conditional. A fixed chain of search, retrieval, synthesis, and composition can tax trivial requests with planning and coordination overhead. Box's design instead keeps one parent decision point and makes children an on-demand execution mechanism.

The implementation details also identify where production work accumulates. Citation attachment, prompt-cache policy, context summarization, permissions, and the movement of intermediate results are not auxiliary features; they determine whether a multi-document answer is usable, affordable, and explainable. A team can retain model choice while standardizing those controls. The reported speed figures are company claims rather than independently audited benchmarks, but they make the architectural trade-off legible: reuse the harness primitives and concentrate engineering effort on the enterprise-specific content and workflow layer.

## What happens next
- **Box will expand agent memory and knowledge composition rather than return to a fixed specialized-agent graph.** (12 months, 65%). Watch for: a product announcement describing persistent or richer institutional knowledge features.
- **More enterprise agent stacks will expose middleware-like controls for citations, context limits, and artifact handoff.** (12 months, 70%). Watch for: product documentation that treats these controls as first-class runtime configuration.

## Limits and uncertainty
This is a vendor case study published by LangChain and based on Box's account. It does not provide independent latency, quality, cost, reliability, or security measurements, nor does it quantify the workloads behind the reported threefold iteration improvement or fourfold faster architecture delivery. It says Box respects existing permissions, but does not explain authorization enforcement in enough detail to assess its security properties. The article also does not establish that full-tool access will outperform selective tool routing for other models, tool sets, or organizations. Finally, the roadmap reference to richer memory is directional, not a dated release plan.

## Skill to build now
Take one existing agent workflow and separate requests into two classes: those that can be completed directly and those requiring a written plan plus parallel evidence gathering. For the second class, define a small artifact contract for each worker: inputs, permitted tools, output format, citations, and completion condition. Then place transcript summarization, cache policy, and evidence attachment in a shared middleware layer rather than duplicating them inside every worker prompt. Measure the extra coordination time against answer quality before making delegation the default.

## Reader takeaway
Box's case argues for selective recursion, not universal multi-agent choreography. Keep simple requests direct; create isolated workers only when a task has separable evidence or analysis stages. The enduring asset is the runtime around the model: tool access, artifact exchange, citations, caching, context management, and permissions-aware delivery.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Agent Memory](https://newruntime.com/topics/agent-memory.md): Explore the agent-memory topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Source Ledger](https://newruntime.com/source-ledger.json): Inspect the public source evidence graph.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)