How can I subclass MessageState or use Pydantic to create separate communication channels in LangGraph?

I am building a hierarchical LLM agent workflow with LangGraph where a research team conducts research and a writing team compiles a report. The workflow runs separately for each sub-section of the report, and each team follows a structure with a Team Supervisor node and Worker nodes. I need both teams to communicate on separate channels (states) for the sub-section topic and content while still sharing some common information.

The challenge is that the current design appends all messages to a single list, causing disjointed outputs and premature termination (hitting the __end__ state before completing all sub-sections). I want to modify this behavior by subclassing MessageState or using a Pydantic approach to maintain separate channels for section_topic and section_content that both teams can update as needed.

Below is the code representing my current attempt:

Supervisor Node Function:

PYTHONCopied
class SupervisorInput(MessagesState):
    """User request."""
    main_topic: Annotated[str, ..., "The main topic of the request"]
    section_topic: Annotated[Optional[str], "Sub-section topic of the main topic"]
    section_content: Annotated[Optional[str], "Sub-section topic content"]

def make_supervisor_node(llm: BaseChatModel, system_prompt: str | None, members: List[str]) -> str:
    options = ["FINISH"] + members
    
    if system_prompt is None:
        system_prompt = (
            "You are a supervisor tasked with managing a conversation between the"
            f" following teams: {members}. Given the user request,"
            " respond with the team to act next. Each team will perform a"
            " task and respond with their results and status. You should verify"
            " the task performed by the teams to ensure it statisfies user request."
            " When finished, respond with FINISH."
        )
    
    class SupervisorAction(TypedDict):
        """Supervisor action."""
        # main_topic: SupervisorInput
        section_topic: Annotated[str, "Sub-section topic of the main topic"]
        section_search_query: Annotated[Optional[str], "Search query for the sub-section topic"]
        next: Literal[*options]

    def supervisor_node(state: SupervisorInput) -> Command[Literal[*members, "__end__"]]:
        """An LLM-based decision maker."""
        
        # print(f"Supervisor Node State: {state}")
        
        messages = [
            {"role": "system", "content": system_prompt},
        ] + state["messages"]
        
        response = llm.with_structured_output(SupervisorAction).invoke(messages)
        print(f"Supervisor reponse: {response}")
        
        goto = response["next"]
        
        print(f"Going to node: {goto}")
        
        if goto == "FINISH":
            goto = END

        return Command(goto=goto)

return supervisor_node

Research Team Graph:

PYTHONCopied
## Define tools
research_tools = [TavilySearchResults(max_results=5), PubmedQueryRun(), SemanticScholarQueryRun()]

## Define LLM
research_llm=ChatOpenAI(model="gpt-4o-mini", temperature=0)
tavily_agent = create_react_agent(research_llm, tools=research_tools)

def tavily_node(state: SupervisorInput) -> Command[Literal["supervisor"]]:
    
    result = tavily_agent.invoke(state)
    
    return Command(
        update={ 
            "messages": [
                HumanMessage(content=result["messages"][-1].content, name="tavily")
            ]
        },
        # We want our workers to ALWAYS "report back" to the supervisor when done
        goto="supervisor",
    )

research_supervisor_prompt = ''.join(open("./prompts/research_supervisor_prompt.txt","r").readlines())
# print(research_supervisor_prompt)

research_supervisor_node = make_supervisor_node(research_llm, research_supervisor_prompt,
                                                ["tavily"])
## Define Research Team
research_team = StateGraph(SupervisorInput)
research_team.add_node("supervisor", research_supervisor_node)
research_team.add_node("tavily", tavily_node)
research_team.add_edge(START, "supervisor")
research_graph = research_team.compile()

The code runs, but the LLM output becomes disjointed—sometimes hitting the __end__ state without processing all sub-sections—and continual appending to the messages list seems ineffective. I need to know how to design a subclass of MessageState (or a similar Pydantic model) that supports separate channels for updating section_topic and section_content during the workflow.

Any guidance or examples on managing these state channels for inter-team collaboration would be greatly appreciated.