Building a Deep Research Agent with Systems Architecture pt. 2
Breaking Down the System into Subcomponents
Systems Architecture is a framework that turns complex mechanics into clear systems.
Welcome back. If you want to start at the beginning of this series, go to part 1.
We are building a Deep Research Agent leveraging Systems Architecture. Step 1 was about identifying the high-level function and form of the system. We did that. This system’s high level form is a web application and its high level function is to deliver enhanced knowledge to the user. Step 1 is simple.
Form = the structure of components and their layout.
Function = the purpose the system fulfills.
Now let’s execute step 2, which is breaking down the form of the system into subcomponents.
We can define the form of a system as the subcomponents that it is comprised of and the way that those subcomponents are laid out. Each component will have at least one subcomponent and each subcomponent might have nested subcomponents.
This is the first breakdown of the system. It remains a remarkably simple division of parts that don’t tell us much about what is happening under the hood. That’s about to change.
When we break down the subcomponents into subcomponents, we can begin to see how these parts work together to deliver the ultimate function: enhanced knowledge to the user.
The frontend renders information for us in the web browser and the backend contains the logic that creates that information and a way to store it (in a database).
Now let’s take it another layer deeper. Let’s not leap into the backend just yet, I want to show you another layer of decomposition first. The formal components are in beige and the blue circles are actually their functions.
As we can see, when we break down the main component into subcomponents, we can begin to see how these parts work together to deliver the ultimate function: enhanced knowledge to the user. The frontend renders information for us in the web browser and the backend contains the logic that creates that information and stores it in a database.
In the MITxPro Systems Architecture course, Architecture of Complex Systems, the instructor defines Systems Architecture as:
The set of decisions you make early in the construction of the system that have outsized influences downstream.
How to Divide the System
To break down your system, you need to consider the form of the system. When we think of form, we want to think about two things: what objects are a part of the system, and what the structure or the layout of those objects is: how the objects are connected.
The process of breaking down a components into subcomponents is really quite simple. The main focus is to look at a part, see what essential components make up that part, and create a nested subcomponent. The general rule is this: if you will be modifying the subcomponent down the road, you should include it.
The second part, identifying how the objects are structured, can involve more thinking. You need to identify how the objects are physically connected, how the objects are laid out spatially, and in what sequence the objects operate.
Keep in mind that while there are many levels, you should only stay at the hierarchical level that will actually help you put the system together. Any further breaking down of the system is overkill.
Here is a high-level breakdown of the backend with most of the essential components and a few of the essential methods.
Envisioning the System: Considering the Function
To effectively wield the tool of systems architecture, you need to envision what functionality you want to create for the user. The function will guide the way the form is put together. Envision the story of how your user is going to use the Deep Research Agent. They are going to login, and view the form of the UI. It should be easy to use and simple. It should also be implemented on the backend so that it’s fast and easily usable. Saved data should be easily accessible and there should be a limit of deep research interactions so that you as a company can make a profit.
All of these properties will eventually be translated into the form of your code and the way you put the system together. You need to build the right data model for storing the information the user produces, you need to build a scratchpad that is fast, you want the user to be able to view/delete past interactions, you want your prompts to be converted into effective prompts... etc.
Here is a final version of this high-level architecture of our system. As we continue, we will continue to add information about sequences of events, visual organization, and physical/virtual connections.
Conclusion
We've now mapped the anatomy of our Deep Research Agent: from its high-level form as a web application down to the subcomponents that deliver enhanced knowledge to users. You have the blueprint.
In Part 3, we'll explore the critical connections between these components. We'll examine data flow, visual layout, and the sequence of operations that transform a user's question into deep, actionable insights.
But here's my challenge to you: before reading Part 3, sketch out your own component connections. This exercise will sharpen your architectural thinking and prepare you to extract maximum value from what comes next.
Every week, I build something effective, share it with the world, and explore what I learned from it. I hope to see you next week.