Why this matters: Build and maintain a dated taxonomy based on execution responsibility. Classify candidates by what their package or service actually owns; then test a representative workflow, including failure and resume behavior, before committing to an abstraction.

What you will be able to do
- Classify agent-related offerings by the operational responsibility they assume rather than by broad product labels.
- Distinguish framework-native features from optional packages, hosted services, provider capabilities, and application-owned architecture.
- Create versioned official-evidence cards that reveal language, runtime, license, migration, storage, and deployment assumptions.
- Design a representative failure-and-resume prototype that tests state, tool side effects, traceability, and exit cost.
1. Turn the request into an architecture decision
Decision first: resist the category jump. The claims POC does not yet demonstrate a need for a multi-agent framework. It demonstrates a need to preserve conversational context, call two controlled business tools, stop for an approval, resume safely, and show an auditor what occurred. Those are different responsibilities, with different owners. If you select an offering because it appears in a “top agent frameworks” comparison, you can accidentally buy a graph runtime when you only need an explicit application loop—or adopt a lightweight SDK while silently rebuilding durable execution, storage, approvals, and tracing yourself.
Start your Decision Portfolio entry with a one-sentence decision: “Select the smallest implementation boundary that can execute a claim-intake workflow with approval, recoverable state, and inspectable tool actions under our data and deployment constraints.” Then add five acceptance criteria: (1) no claim draft is created before an authorized approval; (2) an interrupted run resumes without duplicating an external write; (3) every tool input/output is attributable to a claim and actor; (4) conversation data has an approved storage and retention owner; and (5) substituting a model does not require rewriting domain tools or approval rules. Also record non-requirements: for example, no autonomous delegation, no general long-term memory, and no hosted web search in version one.
This framing prevents a common abstraction leak: calling a product’s “memory” primitive durable business state. Conversation history may help model context; it is not, by itself, an authoritative claim record, an idempotency ledger, or an approval audit trail.
2. Build the taxonomy from what each layer owns
Use responsibility as the taxonomy axis. A refreshable taxonomy asks: “What does this candidate primarily run or own?” The same offering may span more than one category, but its evidence card must identify the boundary.
- Direct model API. Your application owns the loop, retry policy, tool dispatch, state, and tracing. Use this baseline whenever the flow is short and deterministic enough to express directly. It is not “less serious”; it is often the lowest-lock-in control plane.
- Lightweight agent SDK. The SDK manages an agent loop around models and tools while your application supplies business infrastructure. The OpenAI Agents SDK documents that
AgentplusRunnermanages turns, tools, guardrails, handoffs, and sessions; it explicitly says to use the Responses API directly when you want to own that loop. Its runner repeats model calls after tool calls or handoffs and enforces an optional turn limit. ([openai.github.io](https://openai.github.io/openai-agents-python/agents/?utm_source=openai)) That is a meaningful execution abstraction, not a claim that it replaces your authorization service or system of record. - Stateful orchestration / graph library. This category makes workflow state and transitions first-class. LangGraph’s persistence documentation says a compiled graph with a checkpointer saves graph state as checkpoints at execution steps, organized into threads; it connects this to interrupts, replay/debugging, and fault recovery. ([docs.langchain.com](https://docs.langchain.com/oss/python/langgraph/persistence?utm_source=openai)) Choose it when explicit branches, loops, step-level state, resumability, and inspection are core requirements—not merely because multiple prompts exist.
- Multi-agent framework or pattern layer. This coordinates distinct agents through delegation, messages, handoffs, or a graph. It may be implemented atop either an SDK or graph runtime. OpenAI’s own guidance distinguishes manager-style agents-as-tools from handoffs and asks who owns the final answer. ([openai.github.io](https://openai.github.io/openai-agents-python/quickstart/?utm_source=openai)) For claims intake, one accountable orchestrator plus deterministic business services is usually easier to govern than peer agents negotiating authority.
- Data-centric agent library. Its primary value is grounding, retrieval, indexes, document processing, or data connectors. Do not call it a workflow engine merely because it can invoke a model. Evaluate retrieval quality, source attribution, tenancy filters, re-indexing, and data lifecycle separately.
- Model-provider kit. A provider SDK can combine agent primitives with provider-native state, tools, and observability. Google ADK documentation exposes session services that create, retrieve, list, delete, and append events to sessions, including state updates from event deltas. ([google.github.io](https://google.github.io/adk-docs/api-reference/java/com/google/adk/sessions/BaseSessionService.html?utm_source=openai)) This is evidence for session/state concepts; it is not proof that every deployment backend, retention policy, or cross-provider feature is identical.
- Durable-execution integration. A framework adapter to a workflow runtime, database, or durable host adds restart and scheduling semantics. It is distinct from the base agent package. Validate exactly which actions are replayed, how side effects are idempotent, and whether code or state compatibility is your responsibility.
- Observability/evaluation platform. A trace viewer, evaluator, or monitoring service observes and assesses runs; it does not automatically govern execution. For example, the OpenAI SDK quickstart directs developers to a dashboard trace viewer, while the SDK also exposes per-run usage counters. ([openai.github.io](https://openai.github.io/openai-agents-python/quickstart/?utm_source=openai)) Decide whether those artifacts meet your audit and export requirements.
- Hosted agent service. A managed control plane may provide hosting, identity integration, storage, tools, or scaling. Treat it as a separately procured deployment and data boundary even if it has a matching open-source SDK.
3. Mark the boundary: native, optional, hosted, or yours
Make the evidence card before the comparison table. For each candidate, capture the date checked (for this lesson: September 10, 2026), exact package and version tested, language/runtime, license, supported model interfaces, and maturity/migration signals. Then enter only evidence you can point to in official documentation, repository metadata, or release/migration notes.
Illustration: Microsoft Agent Framework’s official documentation currently presents agents, workflows, conversations/memory, middleware, checkpoints/resuming, hosting, and migration material; its official repository describes Python and .NET support and an MIT license. ([learn.microsoft.com](https://learn.microsoft.com/en-us/agent-framework/?utm_source=openai)) That supports categorizing it as a cross-language agent/workflow framework with integration and hosting surfaces. It does not establish feature parity for every Python and .NET package or prove that your chosen provider connector is production-ready. The documentation’s migration area is a signal to record transition status and breaking-change exposure, not an automatic reason to reject it. ([learn.microsoft.com](https://learn.microsoft.com/en-us/agent-framework/migration-guide/?utm_source=openai))
For LangGraph, record persistence as framework-native only when you configure an appropriate checkpointer. The official docs name in-memory persistence for experimentation and separate SQLite, Postgres, and Cosmos DB checkpointer libraries. ([docs.langchain.com](https://docs.langchain.com/oss/python/langgraph/persistence?utm_source=openai)) Therefore, “durable state” belongs in your table as native abstraction + separately selected storage implementation, with database operation, encryption, backup, retention, and access control remaining system-design work. Also flag graph evolution: LangGraph warns that deploying changed graph code against persisted thread state makes each change a backward-compatibility concern for existing checkpoints. ([docs.langchain.com](https://docs.langchain.com/oss/python/langgraph/backward-compatibility?utm_source=openai))
For OpenAI, separate the SDK from the provider platform. Local Python function tools are application code; OpenAI-hosted web search, file search, code interpreter, hosted MCP, and image generation are provider-hosted tool categories. ([openai.github.io](https://openai.github.io/openai-agents-python/tools/?utm_source=openai)) A local tool may improve portability, while a hosted tool may reduce operations. Neither is universally better: your claims-data classification, egress rules, incident ownership, and desired exit path decide.
4. Test the category boundary under failure, not on a happy-path demo
Shortlist by mismatch, then run a bounded trial. For the claims scenario, maintain three deliberately different candidates: (A) direct Responses API plus an application-owned state table and approval endpoint; (B) a lightweight agent SDK with local session/storage choices; and (C) a stateful graph/runtime candidate with a production-like checkpointer. A multi-agent alternative is not shortlisted unless a concrete requirement emerges, such as separately governed expert services with distinct tool authority.
Implement the same thin vertical slice in each: collect claim facts; call a read-only policy tool; propose a structured draft; pause for supervisor approval; call a side-effecting draft-write tool only after approval; simulate process termination immediately after the external call begins; resume; and inspect whether one, and only one, draft exists. Use idempotency keys independent of the framework. LangGraph’s functional guidance specifically advises keeping API calls inside checkpointed tasks and designing them to be idempotent because retries or re-execution can otherwise duplicate effects. ([docs.langchain.com](https://docs.langchain.com/oss/python/langgraph/functional-api?utm_source=openai))
Measure only what your team runs: successful completion rate on a fixed redacted scenario set; invalid tool-argument rate; duplicate-write count; ability to identify the approval decision in a trace; median and tail elapsed time; request/token use where the SDK/provider exposes it; and operator steps needed to diagnose and resume. Do not turn these into a cross-company benchmark. Preserve the fixtures, model IDs, temperatures, tool stubs, package lockfiles, region, and dates so the test can be repeated after an upgrade.
Finally, score fit rather than feature volume. A direct API implementation wins if it passes the recovery and trace tests with materially less complexity. A graph-oriented choice wins if interruptions, replayable state, and changing workflow paths are central enough to justify state schemas and compatibility discipline. A provider kit wins when its managed capabilities fit approved data boundaries and the team accepts dependency concentration. Any candidate fails if it cannot explain its state, tool authorization, operational handoff, and migration plan.
5. Practical exercise and key takeaways
Portfolio exercise — create a refreshable landscape card. In 90 minutes, produce a one-page decision artifact for the claims assistant.
- List six required outcomes, three non-requirements, two data-boundary constraints, and one explicit exit requirement.
- Create evidence cards for four offerings drawn from at least three categories: direct model API, lightweight SDK, graph/stateful orchestration, and either a provider kit or Microsoft Agent Framework. Include official source, checked date, package/version, runtime/language, license, migration status, and whether each claim is package-native, optional, hosted, or custom.
- Build the same approval-and-resume slice for two finalists. Force a tool timeout and a process restart; inspect traces and persistent records.
- Write a 250-word recommendation: selected boundary, rejected category mistake, unresolved uncertainty, next validation, and rollback/migration path. Add the artifact, fixtures, and evidence links to your AI Agent Framework Decision Portfolio.
Decision standard: a reviewer should be able to see why the chosen abstraction is proportionate to the workflow, what it does not solve, and how the team can re-run the evidence after a framework or provider release.
Portfolio Lab: Taxonomize and Shortlist a Claims Assistant Stack
Scenario: You are the lead architect for a regulated-insurance claims assistant. The proof of concept used a single OpenAI Responses API call plus two local tools: policy lookup and claim-draft creation. Product now requests multi-turn claim intake, supervisor approval before a draft is written, resume-after-outage behavior, auditable traces, and eventual support for a second model provider. A stakeholder proposes selecting a “multi-agent framework” immediately because it advertises tools, memory, and handoffs. Your task is to prevent an architecture-category mistake: determine which responsibilities are genuinely required, identify where they belong, and produce a short, refreshable shortlist rather than adopting the broadest-looking SDK.
Work in pairs: one learner acts as framework advocate and must substantiate every claim with an official evidence card; the other acts as operations reviewer and challenges ownership, storage, retry, authorization, and migration assumptions. Swap roles before making the recommendation. Store dated evidence, lockfiles, test fixtures, trace exports or screenshots, results, and the final decision memo in the AI Agent Framework Decision Portfolio.
Self-review checklist
- Write the workflow’s non-negotiable requirements and its explicit non-requirements.
- Create a candidate evidence card from official documentation, repository metadata, release notes, and migration material.
- Label every claimed capability as package-native, optional integration, hosted platform, model-provider service, or custom application logic.
- Prototype one approval interruption, one tool failure, and one resumed run using representative redacted data.
- Capture traces, outputs, tool arguments, latency, token/request counts where available, and recovery behavior using a learner-run test harness—not synthetic rankings published elsewhere in the course materials only if reproducible by your team is absent. Document measurements as environment-specific results, not universal benchmarks.`,`
Key takeaways
- A framework category is a statement about the primary responsibility it assumes, not a marketing label or a feature checklist.
- Separate package-native capabilities from optional adapters, provider-hosted services, and application-owned controls before scoring candidates.
- Treat state schema, tool contracts, traces, and deployment assumptions as migration surfaces—not incidental implementation details.
- Use a direct model API when your needed control loop is small and explicit; add a framework only when its operational responsibilities justify its abstraction and exit cost.
Useful terms
- Agent loop
- The repeated cycle of model invocation, tool execution or delegation, result incorporation, and termination that turns a model call into an agent run.
- Checkpoint
- A saved representation of execution state from which a workflow can inspect, resume, or sometimes replay work, subject to the runtime’s documented semantics.
- Idempotency key
- A stable identifier attached to a side-effecting operation so retries or resumes can be recognized and prevented from producing duplicate external effects.
- Provider-hosted tool
- A tool executed or managed by a model provider’s service rather than solely by the application process.
Research & review note
This lesson is built from source-traceable research and reviewed before publication. AI Agentic School uses AI as a research and practice tool, not as a substitute for evidence or editorial judgment.
Sources & further reading
- Agents – OpenAI Agents SDK
- Persistence – Docs by LangChain
- Quickstart – OpenAI Agents SDK
- BaseSessionService (Google Agent Development Kit Maven Parent POM 0.2.1-SNAPSHOT API)
- Agent Framework documentation | Microsoft Learn
- Migration Guide Overview | Microsoft Learn
- Backward compatibility – Docs by LangChain
- Tools – OpenAI Agents SDK
- Functional API overview – Docs by LangChain