← All perspectives

Perspective / AI solutions

Managed agents or custom orchestration? An architecture decision framework for enterprise AI

The enterprise AI architecture decision spans orchestration, data boundaries, tool authority and operational ownership. Compare managed and custom components using a reference design and explicit evidence, rather than a binary build-or-buy slogan.

11 min readReviewed

Conductor directing an orchestra under warm stage lighting.
Conceptual editorial image.

The choice between managed agents and custom orchestration is best made layer by layer. A provider can run the agent loop while the business retains its data access, authorisation and commercial workflow. Alternatively, a deterministic application can use a model for one bounded step without handing it control of the process. The right architecture depends on the task, information boundaries, recovery requirements and operating capability. This article develops a decision framework for a hypothetical commercial due-diligence assistant and makes the ownership trade-offs explicit.

The executive view

  • Allocate architecture and operating responsibility layer by layer.
  • Use dynamic agency only where the task benefits from adaptive tool use.
  • Keep business authority, authoritative state and acceptance evidence explicit.
01

Break the system into decisions that can be owned

Separate the user experience, workflow state, model interaction, retrieval, tool execution, authorisation and operational telemetry. “Managed AI” can describe different combinations of these responsibilities. A product that hosts a model does not necessarily own workflow recovery; an agent runtime does not necessarily enforce the organisation’s record-level permissions.

OpenAI’s September 2026 Agents API announcement introduced a managed harness and infrastructure for long-running agents. It illustrates why the decision has moved beyond selecting a model endpoint. Orchestration, context and execution environments can now be part of the purchased capability.

For each layer, record the required behaviour, provider responsibility and retained business responsibility. Ask who detects failure, who can correct it and where the authoritative state lives. A commercial sponsor should be able to see which operational burdens are being transferred and which remain with the organisation. Procurement of a runtime is not the same as procurement of a complete accountable business service.

Managed products are already sufficiently different that a generic build-versus-buy scorecard can mislead. Claude's Managed Agents overview also describes a hosted harness; product availability, supported environments and contractual conditions need checking for the intended deployment. Neither vendor's description should be read as a promise that every business boundary, retention requirement or operating need is satisfied automatically.

Create a responsibility matrix using verbs: who authenticates, persists, retries, approves, deletes, alerts and restores? A row labelled security is too broad to answer those questions. Include the integration partner and internal operations team where they carry part of the obligation. For a due-diligence report, the provider may keep the agent running while the application controls which documents can be retrieved and the reviewer controls final use. That separation makes the architecture assessable. It also creates concrete procurement questions about observable behaviour and support, rather than a general belief that outsourcing the runtime outsources accountability.

02

Decide whether the workflow needs dynamic agency

Our hypothetical due-diligence assistant reviews an approved document set, extracts commercial risks and prepares an internal report. Some steps are predictable: check access, identify documents, run extraction and save a draft. Others may need adaptive investigation, such as resolving contradictory contract terms within the approved evidence.

Anthropic’s architectural guidance, originally published in December 2024, distinguishes predefined workflows from systems where a model dynamically directs tool use. That distinction remains useful even as specific tooling changes. Start by locating the genuinely variable part of the task rather than making the whole process autonomous.

A deterministic outer workflow can own identity, permissions, deadlines and report delivery, while an agent handles a bounded research stage. This hybrid limits the consequences of unexpected behaviour and makes operational progress easier to explain. Additional autonomy should solve an identified limitation, with evidence that the benefit exceeds the extra testing and control burden.

Classify the decisions before granting tools. A deterministic check can establish whether the user may access the engagement. A model can help identify clauses that merit review. An adaptive research stage can investigate a contradiction by retrieving additional approved documents. A separate human decision can determine the commercial significance of the finding. These steps need not share the same execution mechanism.

Test whether dynamic agency improves a representative task set enough to justify its additional failure modes. Compare it with a bounded sequence using the same evidence and completion standard. Measure the rate of acceptable reports, unsupported conclusions, unnecessary tool calls and time to reviewed completion. A longer tool trace is not evidence of better reasoning. If a fixed retrieval-and-extraction workflow handles the important cases reliably, keep it as a credible alternative. If the agent helps with genuinely variable investigations, limit its authority to that stage and define how it returns uncertainty. That creates a scope decision supported by task evidence rather than a commitment to autonomy across the entire product.

03

Specify context and data boundaries as testable contracts

List what the system may receive: approved documents, account metadata, relevant policies and prior task state. Then specify what it must not receive, including unrelated client material or credentials that belong only inside an integration service. Context selection is both a quality decision and an information-boundary decision.

For a commercial assessment, retain document identifiers and versions alongside extracted evidence. If a report cites an amended contract, the reviewer should be able to establish which version informed it. Summarisation and context compaction can reduce processing demands, but the design needs a policy for preserving material qualifications and recovering the original source.

Assess provider terms and deployment options against the actual data classification, retention needs and contractual obligations. Do not assume that a managed runtime, private network label or chosen hosting region resolves every requirement. Record the verified arrangement and any unresolved condition in the architecture decision, then test the implemented data paths against that record.

Version the retrieval boundary as part of the task. A report created against document set A should not silently claim to reflect a later amendment added to set B. Record the source inventory and expose whether the answer needs refreshing. When the user loses access during a long-running task, decide whether execution is cancelled, restricted or referred for review. Do not let an earlier access check become an indefinite permission grant.

Minimise secrets and sensitive metadata in the execution environment. A tool can accept an opaque document reference and use a server-side credential after checking identity and record scope. Returning an access token to the model creates a different exposure. Review logs and traces as additional data stores: prompts, extracted passages and tool results can contain the same confidential information as the source repository. Give telemetry an explicit retention and access policy. Managed and custom approaches both require that review, although the available controls and division of responsibility differ by product and deployment.

04

Keep business authority outside the orchestration engine

Whether the agent loop is managed or custom, tools should expose bounded business operations. The model may propose fetching a contract or saving a report draft; an application service should resolve identity, check record scope and validate the operation before it executes.

For the due-diligence assistant, an approved document reference should not become a route to arbitrary storage access. Similarly, a tool for saving an internal report should not allow the model to select any external recipient. A narrow adapter can enforce those conditions consistently across more than one runtime or model.

This separation also improves portability. Business rules remain in an owned service rather than being scattered across prompts or deeply coupled runtime callbacks. It does not eliminate integration work: the adapter still needs authentication, versioning, error handling and monitoring. Its value is a clear boundary where the organisation can explain and verify what an AI component is allowed to cause.

Bind approval to a specific proposed operation. If an action is consequential, store the intended target, parameters, evidence version and permitted scope with the approval. A model should not obtain approval for one report distribution and then substitute another recipient or attachment. Revalidate at execution time, including whether the approver still has the necessary authority.

Treat tool output and retrieved documents as evidence with an origin, rather than instructions that may redefine authority. A contract containing text that asks the assistant to email its contents should not gain control over a delivery tool. Test these attempts through the actual adapter and runtime combination. A prompt that says to ignore such text is useful guidance, but permission enforcement belongs at the operation boundary. Preserve the rejected attempt in an appropriate audit trail without unnecessarily copying confidential content. This design gives the organisation a place to verify what can happen even when model behaviour is imperfect or the runtime changes.

05

Design completion, retries and recovery before the happy path

Long-running work raises questions that a conversational demonstration may never expose. What happens when the user closes the browser, a document service times out or a job resumes after partial completion? Which step is safe to repeat, and which side effects require an idempotency key?

Keep an authoritative task state with explicit transitions such as queued, processing, awaiting review, completed and failed. A model-generated message saying “finished” should not be the only completion signal. Verify that the report exists, its references resolve and its review status is correct before notifying the user.

Set time and resource budgets for the agent stage. Provide a controlled outcome when evidence is insufficient or the budget is exhausted. A custom runtime gives the organisation responsibility for implementing these mechanisms; a managed runtime may provide some primitives, whose exact behaviour still needs verification. Evaluate observable recovery semantics rather than assuming that infrastructure reliability equals correct business-process recovery.

Use failure injection in the architecture trial. Stop a worker after it writes a draft but before it marks the task complete; revoke access between retrievals; repeat a completion webhook; interrupt a long tool call. For each case, inspect durable state and the action visible to the user. The requirement is a recoverable, explainable task, not an uninterrupted internal process.

A useful task contract distinguishes terminal failure, retryable interruption and a result awaiting human judgement. Each needs an owner and a next action. Budget exhaustion can produce a partial report with explicit unresolved questions, but it should not masquerade as a complete assessment. Keep retries bounded and identify side effects with durable operation identifiers where appropriate. In a managed service, verify what the platform replays and what the application must deduplicate. In a custom service, implement and test those responsibilities directly. A provider's availability commitment is relevant procurement evidence; it does not by itself establish the correctness of the application's recovery semantics.

06

Use an architecture decision record with explicit rejection criteria

A concise decision record can compare a managed loop, a custom loop and a deterministic workflow with a bounded model step. Score only requirements that have been defined and evidenced. Avoid a decorative weighted matrix that masks a mandatory constraint with unrelated strengths.

Decision dimensionEvidence to obtain
Task qualityRepresentative evaluation results using the same acceptance standard
Data boundariesVerified flows, retention settings and contractual fit
Tool controlRecord-scope and operation enforcement tests
RecoveryTimeout, replay and partial-completion behaviour
Operating costAccepted-task economics including review and support
ExitExportable state, owned tool contracts and migration effort

For the hypothetical assistant, a managed research stage may be appropriate if it meets the evidence and boundary requirements, while the application retains permissions and final delivery. If a mandatory information restriction cannot be satisfied, that option is rejected rather than rescued by an attractive average score. Record why the selected scope is adequate and what would trigger reconsideration.

Compare costs using an accepted, reviewed report as the unit. In a hypothetical monthly workload of 1,000 reports, an additional £2 of runtime cost per report is £2,000. If an option saves five minutes of review per report at an illustrative loaded rate of £60 per hour, it releases about £5,000 of task capacity. That could justify the extra runtime spend, subject to quality and the ability to use the capacity. These figures are invented and make no statement about either provider's prices.

The reverse is also possible: an apparently inexpensive runtime can generate more failed tasks, longer evidence searches or additional support work. Run the same representative workload against each candidate and retain the cost boundary, task quality and operating assumptions. Include the effort to maintain a custom harness and the retained integration work for a managed one. The commercial decision should therefore compare complete service configurations, with a clear rejection rule for unacceptable authority or data behaviour, rather than selecting the smallest model bill.

07

Approve ownership as well as technology

Name the service owner, operational support path and decision-maker for changing models, tools or permissions. A custom implementation requires capacity to maintain its runtime and integrations. A managed approach requires capacity to assess provider changes and verify that the purchased service still meets the business contract.

Preserve the assets that make a future change possible: task definitions, representative evaluation fixtures, source references, tool contracts and business state. Full portability may be neither achievable nor economically sensible, but the organisation should know where the dependencies sit and what an exit would involve.

The board-level decision is therefore a controlled allocation of ownership. Buy capabilities where their verified behaviour and operating economics fit the task. Retain controls whose authority or commercial specificity requires direct ownership. Review the architecture when workload, data sensitivity or permitted actions materially change. That produces a defensible enterprise design without assuming that either maximum customisation or maximum outsourcing is inherently the more mature choice.

Further questions

Questions this raises

What is an agent harness?

It is the software around a model that coordinates an agent’s execution, such as context handling, tool calls and progress through a task. Its exact responsibilities depend on the product or implementation.

Can managed agents use business-owned authorisation controls?

Yes, an architecture can keep record access and action permissions in owned integration services. Whether a particular product supports the required arrangement must be verified through its interfaces and actual deployment design.

When is a deterministic workflow preferable to an agent?

When the process is predictable and its decision path can be specified reliably, a conventional workflow with bounded model steps can be easier to test and operate. Dynamic agency is useful where adaptive investigation creates sufficient value to justify additional complexity.

References

Sources & further reading

  1. Introducing the Agents API 10 September 2026
  2. Building effective agents 19 December 2024; tooling caveat checked 17 November 2026
  3. Claude Managed Agents overview

Connected capabilities

AI solutionsSoftware & CRMStrategy & digital transformation

From thinking to doing

What could this mean
for your business?

Your next chapter

What could your
business do better?

Tell us where you want to go, what’s getting in the way, or what you need to deliver. We’ll start there.

Start a conversation

Start a conversation

Tell us what
you have in mind.

Interactive preview. Your information stays in this page and is not sent.