汎用ハーネスからドメイン特化の認知フローへ

In this chapter, we look at how to gradually adapt a general harness to a specific domain. The speaker's recommendation is not to build a dedicated system from the beginning. Start with the common loop, then add gates, checks, summarization, and tool handling where they are needed.

Start with a general harness

A general harness has a common loop: it receives a request, calls the model, uses a tool when needed, and sends the observation back to the next model call. With this loop, you can start running an agent without deciding every step in advance.

As the use case becomes narrower, add processing at specific points in this loop. For example, you can add the following:

• A gate that checks whether conditions are met before calling the model
• Summarization that shortens important information
• Processing that handles tool inputs or outputs for a specific domain
• A check that confirms whether the agent may move to the next stage

What is a cognitive architecture?

Here, a cognitive architecture means a dedicated flow that explicitly defines the order in which an agent proceeds for a particular job. In a general loop, the model decides which tool call to make at each moment. In a dedicated flow, the designer places stages and branches such as search, planning, execution, and validation more clearly. This is not about making the model itself different. It is about adapting the flow that runs the model to the use case.

In the speaker's historical account, models around 2023 to 2024 were not yet good enough to run reliably inside a loop. For that reason, dedicated designs with several fixed stages were useful at the time. However, this is the speaker's account. It should not be treated here as an independently verified conclusion about model performance.

The figure, titled "Custom cognitive architectures," compares a reporting pipeline that uses multiple queries with a structured search, planning, execution, and validation flow.

The figure shows the difference from a general loop that only repeats the same kind of tool call. On the left, several research questions are created before a report is produced. On the right, domain-specific stages and branches—search, planning, execution, and validation—are made explicit.

Example: fan-out in deep research

Deep research is an example that helps explain fan-out. Starting from one request, the system generates several smaller questions to investigate. It then branches and executes them. Finally, it combines the results into a report for the overall research task. In other words, the agent does not simply call one tool at a time. The design divides the work into several lower-level tasks.

The figure, titled "Custom cognitive architectures," shows a research workflow that generates multiple questions, processes them in parallel, and combines the results.

In the diagram on the left, one task enters a research-question generator, splits into several queries, and sends their results to a research agent. The neighboring diagram also contains search, planning, execution, and validation stages. However, not all of its small labels can be read clearly.

Example: a code-review bot

A code-review bot can also keep domain-specific steps visible. It can make the dedicated stages required by code review explicit while putting much of the common execution and tool interaction into the harness. This example shows that dedicated steps and a general harness are not mutually exclusive.

Adding middleware versus redesigning the flow

Adding gates, summarization, and tool handling at loop insertion points is customization that keeps the general harness. A cognitive architecture, by contrast, makes the order and branches of the work more explicit. But it is not a separate system unrelated to the agent loop. In many cases, it uses the common loop as a foundation and layers dedicated stages on top of it.

For a practical decision, it is simplest to begin with an off-the-shelf or general harness. It can provide value quickly. When the use case becomes narrower and higher quality is needed, add gates and checks at the places where failures are likely. If control over the steps and consistency are still important, move toward a dedicated cognitive architecture.

So, you should not assume that a general harness cannot be changed. You also should not assume that customization requires rewriting the whole agent. Customization ranges from small changes that insert processing into the common loop to larger changes that make domain-specific stages explicit.

The main point is to treat generality and specialization as a spectrum. First run the common loop and identify the gates, checks, summarization, and tool handling that the actual use case needs. Then decide how much of the flow should be made explicit.