The problem: context fragmentation

Split a clinical task across multiple agents, and each operates with its own context window. Agent A reviews the patient's allergy history and notes a documented penicillin allergy. Agent B, handling medication recommendations, suggests amoxicillin for a respiratory infection. Without shared context, Agent B does not see the allergy flag. The recommendation reaches the clinician with a contraindicated drug.

This is context fragmentation. The naive solution is to pass everything to every agent, but that does not scale. Clinical encounters generate thousands of tokens. Passing entire history logs to every call eats up context windows, increases latency, and degrades performance.

How the Corti Agentic Framework solves this

The Agentic Framework uses structured data, semantic retrieval, and strict isolation to manage context effectively.

Isolated contexts

Every conversation operates within a context, identified by a server-generated contextId. Data within a context is accessible to agents in that context. Data across contexts is completely isolated. Patient information from one encounter cannot leak into another.

The workflow is simple: send the first message without a contextId, receive one in the response, and include it in subsequent requests. The framework handles memory automatically from there.

Automatic memory with semantic retrieval

Every TextPart and DataPart sent is automatically indexed and stored in the context's memory. When an agent processes a new message, the system performs semantic search across all indexed content, retrieves the most relevant information, and injects it into the agent's prompt automatically.

If you ask about the patient's chief complaint in message ten, the system retrieves it from message two. No manual history management required.

This works based on meaning, not keyword matching. Only relevant information gets retrieved, keeping token usage efficient. Less code to write, less logic to maintain, fewer edge cases where important information gets dropped.

Structured data with DataParts

The framework supports DataPart objects for passing structured data alongside text: patient records, clinical facts, FHIR resources, metadata. This keeps information machine-readable and properly typed.

You can combine automatic memory via contextId with explicit context via DataPart for maximum control. Pass structured data when you need to provide specific information for a particular request. Let automatic memory handle the rest.

Scoped expert contexts

Experts operate with context scoped to their domain. The orchestrator manages what each expert sees, ensuring they have enough context without being overwhelmed by irrelevant information. A coding expert does not need to see scheduling data. A documentation expert does not need billing details.

Data isolation at the framework level

Multi-agent systems serving concurrent users create access control challenges. The naive approach is to trust the model to stay in bounds. This fails. An agent that hallucinates a patient ID does not know it crossed a boundary.

Strict context isolation solves this architecturally. Data cannot leak across contexts because the system enforces isolation at the infrastructure level. Each contextId creates a completely separate scope.

What this means for compliance:

• Patient data from one encounter cannot be exposed to another
• Information from different workflows remains properly separated
• You can scope sensitive data to specific contexts without risk of cross-contamination
• Data boundaries are guaranteed by the framework, not hoped for in prompts

When you need to share information across contexts, you explicitly pass it via DataPart objects. There is no automatic data sharing between contexts.

What building context management yourself looks like

Without infrastructure-level context management, you assemble the stack yourself.

The typical approach: Start with an LLM provider (Anthropic, OpenAI, Google). Add an agent framework (LangChain, LangGraph, CrewAI, AutoGen). Integrate a vector database for retrieval (Pinecone, Weaviate, Chroma). Build orchestration logic on top. Wire everything together.

Then you handle:

• Conversation state tracking. You decide what to store from each message, where to store it, and how long to retain it. You build the logic to associate messages with sessions, patients, encounters. You handle edge cases when sessions timeout or resume.
• Summarization and filtering. Context windows have limits. You build logic to summarize long conversations, decide what to keep and what to drop, and maintain that logic as your application evolves. When something important gets filtered out, you debug why.
• Retrieval infrastructure. You configure embedding generation, index management, and query optimization. You tune retrieval to balance relevance against token usage. You maintain this infrastructure as your data grows.
• Token budget management. You track how many tokens each component consumes. You build logic to truncate or prioritize when the budget runs tight. You handle the cases where important context gets cut because something less relevant took up the space.
• Healthcare integrations. General-purpose frameworks give you tools for calling APIs. They do not give you pre-built integrations with DrugBank, PubMed, ClinicalTrials.gov, medical coding databases, or clinical calculators. You build each integration yourself: authentication, error handling, rate limiting, response parsing. You maintain them as external APIs change. You build the domain logic that knows how to use these sources effectively for clinical tasks.
• Isolation and access control. You enforce data boundaries in your own code. You audit that patient data from one context cannot leak into another. You prove this holds under compliance review. General-purpose frameworks do not provide healthcare-grade isolation out of the box.
• Debugging retrieval failures. When an agent makes a bad decision because it lacked context, you trace back through your retrieval logic to figure out why. Was the information not indexed? Was it indexed but not retrieved? Was it retrieved but truncated?

This is months of engineering before you ship anything clinical. And it is ongoing maintenance as your application scales.

The Corti Agentic Framework handles this at the infrastructure level. You get automatic indexing, semantic retrieval, strict isolation, and scoped expert contexts without assembling the stack yourself.

Trusted context engineering out of the box

Context engineering is one of the more challenging parts of building production multi-agent systems. It requires getting retrieval, isolation, and routing right simultaneously. The failure modes are subtle.

The alternative is manual context management: deciding what to include in each request, building logic to summarize or filter, maintaining that code as your application evolves, and handling the edge cases where important information gets dropped.

With the Corti Agentic Framework, this complexity is handled at the infrastructure level. You get context management that scales, data isolation that holds up under compliance review, and semantic retrieval that surfaces the right information automatically.