Models are ready. Infrastructure isn’t.
Agentic healthcare means AI-first workflows: grounded in evidence, humans in the loop, machines doing work that never needed people.
Research before reasoning
Healthcare systems hold the answers. They just do not connect them fast enough. A research agent gathers context, cites sources, and exposes what it cannot verify.
Every high-stakes action must start with: look it up, do not make it up. Retrieval first, synthesis second, citations always. I cover guardrails in Preventing Hallucinations: Building More Honest AI Agents.
func ResearchAgentQuery(patientID string, query string) ResearchResponse {
// Step 1: Retrieve context (never hallucinate)
records := fetchPatientRecords(patientID) // DB lookup
guidelines := searchClinicalGuidelines(query) // Vector DB
// Step 2: Build context with citations
context := fmt.Sprintf("Records: %s\nGuidelines: %s\nQuestion: %s",
records[:2000], guidelines[:2000], query)
// Step 3: Call model with enforced citations
response := model.Generate(context, CitedResponseFormat)
return response // Always includes source references
}
// (This example is complete, it can be run "as is")def research_agent_query(patient_id: str, query: str) -> dict:
# Step 1: Retrieve context (never hallucinate)
records = fetch_patient_records(patient_id) # DB lookup
guidelines = search_clinical_guidelines(query) # Vector DB
# Step 2: Build context with citations
context = f"Records: {records[:2000]}\nGuidelines: {guidelines[:2000]}\nQuestion: {query}"
# Step 3: Call model with enforced citations
response = model.generate(context, cited_response_format)
return response # Always includes source references
// (This example is complete, it can be run "as is")async function researchAgentQuery(patientID: string, query: string): Promise {
// Step 1: Retrieve context (never hallucinate)
const records = await fetchPatientRecords(patientID); // DB lookup
const guidelines = await searchClinicalGuidelines(query); // Vector DB
// Step 2: Build context with citations
const context = `Records: ${records.slice(0, 2000)}\nGuidelines: ${guidelines.slice(0, 2000)}\nQuestion: ${query}`;
// Step 3: Call model with enforced citations
const response = await model.generate(context, CitedResponseFormat);
return response; // Always includes source references
}
// (This example is complete, it can be run "as is") async function researchAgentQuery(patientID, query) {
// Step 1: Retrieve context (never hallucinate)
const records = await fetchPatientRecords(patientID); // DB lookup
const guidelines = await searchClinicalGuidelines(query); // Vector DB
// Step 2: Build context with citations
const context = `Records: ${records.slice(0, 2000)}\nGuidelines: ${guidelines.slice(0, 2000)}\nQuestion: ${query}`;
// Step 3: Call model with enforced citations
const response = await model.generate(context, CitedResponseFormat);
return response; // Always includes source references
}
// (This example is complete, it can be run "as is")CLI-native infrastructure
Agents work best with simple, scriptable, auditable tools. The CLI. Boring in the best way: deterministic, composable, easy to sandbox.
MCP servers are the second-best option. Use read-only ones. Agents gather data, they do not write it.
package main
import "github.com/modelcontextprotocol/go-sdk/server"
// next level minimal MCP server
func main() {
// create server
s := server.NewMCPServer(
server.ServerInfo{Name:"healthcare-data",Version:"1.0.0"})
// patient resource
s.RegisterResource("patient:///{id}", server.Resource{
Name:"Patient",MimeType:"text/plain"},
func(uri string)(map[string]any,error){
// read-only fetch
data := fetchPatientReadonly(extractID(uri))
return map[string]any{"contents":[]map[string]any{
{"uri":uri,"text":data},
}}, nil
})
}
// (This example is complete, it can be run "as is")from mcp import Server
# next level init server
s = Server("healthcare-data")
# patient resource
@s.resource("patient:///{id}","Patient","text/plain")
async def patient(uri:str)->dict:
# extract id
pid = uri.split("/")[-1]
# read-only fetch
data = fetch_patient_readonly(pid)
return {"contents":[{"uri":uri,"text":data}]}
# lab resource
@s.resource("lab:///{id}","Lab","text/plain")
async def lab(uri:str)->dict:
pid = uri.split("/")[-1]
data = fetch_lab_results_readonly(pid)
return {"contents":[{"uri":uri,"text":data}]}
// (This example is complete, it can be run "as is")import { MCPServer } from "@modelcontextprotocol/server";
// next level init server
const s = new MCPServer({ name:"healthcare-data", version:"1.0.0" });
// patient resource
s.registerResource("patient:///{id}","Patient","text/plain",async (uri:string)=>{
// read-only fetch
const data = fetchPatientReadonly(extractID(uri));
return { contents:[{ uri, text:data }] };
});
// lab resource
s.registerResource("lab:///{id}","Lab","text/plain",async (uri:string)=>{
// read-only fetch
const data = fetchLabResultsReadonly(extractID(uri));
return { contents:[{ uri, text:data }] };
});
// end
// (This example is complete, it can be run "as is")import { MCPServer } from "@modelcontextprotocol/server";
// next level init server
const s = new MCPServer({ name:"healthcare-data", version:"1.0.0" });
// patient resource
s.registerResource("patient:///{id}","Patient","text/plain",async (uri)=>{
// read-only fetch
const data = fetchPatientReadonly(extractID(uri));
return { contents:[{ uri, text:data }] };
});
// lab resource
s.registerResource("lab:///{id}","Lab","text/plain",async (uri)=>{
// read-only fetch
const data = fetchLabResultsReadonly(extractID(uri));
return { contents:[{ uri, text:data }] };
});
// end
// (This example is complete, it can be run "as is")The CLI is the core interface for healthcare automation. Treat models as pipeline components with strict inputs and outputs. I cover this in Agent-Friendly CLI Tools: From Flaky Agents to Reliable Automation.
Safety is workflow design
Safety is not alignment. It is system design. Models do not deliver safe healthcare. Workflows do.
Traceable steps, schema-locked outputs, rerunnable evaluations. I unpack the engineering side in Reliable Agents: Engineering Reliable AI Agents.
Automatic PII detection and masking. Healthcare data carries names, addresses, SSNs—data no LLM or provider should see. An agentic pipeline strips identifiers before data reaches the model and reconstructs context after processing. This protects patient privacy.
For token efficiency, remap PII to single-token integers:
Reconstruct after model processing:
Schema-locked outputs ensure models cannot return arbitrary fields:
Watch the Anthropic Healthcare and Life Sciences Livestream to learn more.
The consumer-facing evolution
ChatGPT Health launched January 7. It shows what personalized AI agents look like. Connect your health data—Apple Health, Function, MyFitnessPal—and the system grounds responses in your information. Over 230 million people ask health questions on ChatGPT weekly. Now they get answers grounded in their records.
The design follows my principles. Layered encryption isolates health conversations. Physicians built the evaluation framework with 600,000 feedback rounds. The agent cannot diagnose or treat. It helps you understand patterns and prepare for appointments.
Patients arrive at clinical settings with synthesized lab results, relevant research, clear questions. Informed patients make better partners in care. Consumer and clinical sides converge.
Watch the ChatGPT Health announcement to learn more.
The future I want
No autonomous medicine. Cooperative systems. Every clinician needs a research agent that keeps records current, finds relevant evidence, and flags what needs human judgment.
This is not a tech problem. It is integration, policy, trust. That is where the work is.
Disclaimer: I am building an auto-coding healthcare platform for a client. That influences my view on where agentic healthcare is heading.