Add Playbook workflows to agent-framework-quick-start

ToDo: Define 3 workflow use cases.
Goal: 3 workflow use cases are to be relevant to the user, show clear examples of deterministic agnostic, LLM based on MAF, Hybrid deterministic and LLM based on WAF. See addendum for specific wiring instructions.

Context

After Goodtocode.Agents.Playbook has been extracted from crucible-web, published as a Goodtocode NuGet package, and consumed successfully by both hosts, add representative workflows to agent-framework-quick-start.

The workflows must prove that the shared library supports both deterministic CER execution and MAF-backed CER execution while preserving strongly typed stage boundaries.

Workflow 1: Deterministic SQL statistics

Implement a typed CER workflow that:

1. Collects SQL database statistics through a deterministic application query or MAF tool adapter.
2. Evaluates database size against a versioned typed rubric.
3. Records a deterministic materialization for display and optional persistence.

Possible example workflows - Please verify and change or refine.:

Collect:
SqlDatabaseStatisticsQuery -> SqlDatabaseStatisticsEvidence

Evaluate:
SqlDatabaseStatisticsEvidence + SqlDatabaseSizeRubric -> SqlDatabaseSizeFinding

Record:
SqlDatabaseSizeFinding -> SqlDatabaseSizeMaterialization

Requirements:

• The rubric must be a typed versioned object.
• The collection operation must be selected by the workflow, not by LLM tool selection.
• The workflow must support returning the typed result for live display.
• The workflow should optionally persist the typed materialization through an application command.
• Record must demonstrate deterministic transformation of the finding into the presentation or persistence shape.
• No JSON, object, dynamic, or generic dictionary may be used as a CER stage input or output.

Workflow 2: Chat-session taxonomy extraction

Implement a MAF-backed CER workflow that:

1. Collects all messages for a selected chat session.
2. Sends the typed message evidence and taxonomy knowledge/rubric to an LLM through a host-owned MAF adapter.
3. Validates the model response into a typed finding.
4. Applies deterministic Record-stage transformation.
5. Returns or persists the typed taxonomy materialization.

Expected flow:

Collect:
GetChatSessionMessagesQuery -> ChatSessionEvidence

Evaluate:
ChatSessionEvidence + ChatTaxonomyKnowledge -> MAF inference -> ChatTaxonomyFinding

Record:
ChatTaxonomyFinding -> ChatTaxonomyMaterialization

Requirements:

• Reuse the existing typed chat-session and chat-message application queries.
• Do not access DbContext directly from an MAF tool or playbook definition.
• Define a typed taxonomy knowledge/rubric contract.
• Validate the LLM response before Record executes.
• Record must not call the LLM or collect additional messages.
• Record may normalize taxonomy labels, add confidence bands, create summaries, attach message references, or map the finding into a persistence/display DTO.
• Support both live result display and persistence.
• Preserve deterministic replay metadata where practical.
• No JSON CER stage contracts.

Package and project requirements

• Reference Goodtocode.Agents.Playbook through PackageReference.
• Remove any source ProjectReference to the extracted library.
• Verify the workflow runs from a clean package consumer.
• Keep MAF-specific implementations in Infrastructure.AgentFramework.
• Keep application queries, commands, and use cases in Core.Application.
• Preserve dependency direction and existing governance boundaries.

Tests

Add tests covering:

• Typed deterministic SQL statistics execution.
• Small, medium, and large rubric classifications.
• SQL collection failure and cancellation.
• Typed Record transformation.
• Chat-session message collection.
• Valid taxonomy model output.
• Invalid or incomplete model output.
• MAF workflow graph construction.
• MAF-backed evaluation with a deterministic inference test double.
• Live display result.
• Persisted materialization result.
• Package-consumer execution without a source-project reference.

Acceptance criteria

• Both workflows execute through the shared Goodtocode.Agents.Playbook package.
• The SQL workflow runs without requiring an LLM.
• The taxonomy workflow uses MAF for Evaluate only.
• Collect and Record remain deterministic.
• All CER stage inputs and outputs are strongly typed.
• Record transformation is observable in the final result.
• Existing quick-start chat behavior remains passing.
• The workflows can be run from a clean NuGet package consumer.
• No Conductor or Crucible project reference is introduced into agent-framework-quick-start.

---

Addendum: Wiring instructions based on final Goodtocode.Agents.Playbook CER playbook design and tool integration

Title: Implement the three CER workflow types (deterministic, MAF agentic, hybrid) on top of the Playbook foundation

Labels: feature, workflow, agent-framework, draft

Status: draft, depends on the foundation issue being merged to main first. Branch from main only after that merge.

Summary
With the Goodtocode.Agents.Playbook and Goodtocode.Agents.Governance foundation in place (see the foundation issue), implement the three example workflow types discussed for this template, each executing the same example playbook contracts from the foundation work, so the only thing that changes between the three examples is how the stages are orchestrated and which stage implementations are deterministic versus agentic.

The three workflow types

1. Deterministic, framework agnostic playbook workflow. Uses Goodtocode.Agents.Playbook's PlaybookExecutor directly, no Microsoft Agent Framework workflow graph involved. This is effectively already provable from the foundation issue's tests, but this issue should add a dedicated, clearly named example (for instance, a console command, minimal API endpoint, or a dedicated integration test fixture) that a reader of the template can point to as workflow type one.
2. A 100 percent MAF Agent workflow against CER tools. All three stages, Collect, Evaluate, and Record, are performed by agentic, model backed tool implementations, orchestrated as a Microsoft Agent Framework Workflow graph (a three node graph: Collect then Evaluate then Record, matching the pattern already proven in crucible-web's PipelineWorkflowStepExecutor), built and run through Microsoft.Agents.AI.Workflows's WorkflowBuilder and InProcessExecution.
3. A hybrid deterministic and agentic CER workflow in MAF. Collect and Record stay deterministic (reuse the foundation's deterministic tools), Evaluate is agentic and model backed. Same three node MAF graph shape as workflow type two, but the middle node resolves a different tool implementation.

Scope of work

1. Add a PackageReference to Microsoft.Agents.AI.Workflows to Infrastructure.AgentFramework.csproj, matching the version already used for Microsoft.Agents.AI and Microsoft.Agents.AI.OpenAI.
2. Decide, as part of this issue's design discussion, whether the three node MAF graph builder (the Collect, Evaluate, Record Executor wiring, mirroring crucible-web's CollectWorkflowNode, EvaluateWorkflowNode, and RecordWorkflowNode) is written directly in this repository's Infrastructure.AgentFramework project as a host owned adapter, consistent with the documented decision to keep Goodtocode.Agents.Playbook permanently free of a MAF dependency, or whether by this point enough duplication exists across crucible-web and this template to justify extracting a shared, MAF referencing satellite package, for instance Goodtocode.Agents.Playbook.AgentFramework. Record the decision and rationale in docs before implementing.
3. Add one or two new agentic tool implementations for the example playbook's Evaluate stage (and Collect and Record stages, for workflow type two only), each implementing IEvaluateStepTool (or the relevant stage interface) from Goodtocode.Agents.Playbook.Steps, backed by a real model call through this repository's existing AIAgent and ChatClient wiring in Infrastructure.AgentFramework slash ConfigureServices.cs, each decorated with a distinct PlaybookTool key so the resolver can select the correct tool per workflow type.
4. Wire governance so every workflow type, not only the deterministic one, produces a real EvaluationGovernanceRecord per execution, reusing the activity recorder adapter from the foundation issue. Confirm that the agentic Evaluate stage's governance record reflects DeterministicReplaySupported as false, and the deterministic stages reflect true, matching the existing Repeatability replay mode guidance in Goodtocode.Agents.Governance.
5. Add three clearly separated, discoverable examples, one per workflow type, ideally as either dedicated minimal API endpoints under Presentation.Api, or as clearly named integration test fixtures if no new endpoint is desired yet. Each example must be independently runnable and must not require the other two to exist.
6. Add tests for each workflow type:
   a. Workflow one: already covered by the foundation issue, extend only if the new dedicated example needs its own test.
   b. Workflow two: an integration test proving the full MAF graph runs Collect, Evaluate, and Record through agentic tools and returns a governed result, using a stubbed or recorded model response so the test remains deterministic and does not require a live model call.
   c. Workflow three: an integration test proving the hybrid graph correctly dispatches Collect and Record to deterministic tools and Evaluate to the agentic tool, and that swapping the Evaluate tool key is the only difference between workflow two and workflow three's contract, not a different graph shape.
7. Update docs slash governance with a new document describing the three workflow types side by side, explaining what stays constant (the stage contracts, the resolver, the governance record shape) and what changes (which tool implementation is registered per stage), so a reader of the template understands this is a tool substitution decision, not three unrelated architectures.

Non-goals

• No changes to the foundation issue's deterministic example tools beyond what is needed to reuse them in the hybrid workflow.
• No production hardening of the agentic tool's prompt or model choice. A reasonable, working example is sufficient; prompt tuning can follow in a later issue.

Definition of done

• All three workflow types are demonstrable independently.
• All three produce a real, valid EvaluationGovernanceRecord.
• Tests for all three pass locally without requiring a live external model call.
• Documentation clearly explains the three workflow types and the MAF adapter placement decision made in scope item two.

---

Playbook UI Architecture

Design Goals

The UI should present a Playbook as a first-class aggregate with a dedicated detail page.

The user should be able to:

• Navigate between Playbook executions.
• View high-level execution results immediately.
• Understand where they are within the CER lifecycle.
• Inspect Collect, Evaluate, and Record execution details independently.
• Inspect tool execution without understanding internal implementation details.
• See governance metadata at both workflow and stage levels.
• Compare deterministic and agentic workflows using the same user experience.

The UI should emphasize:

• Evidence flow
• Stage progression
• Strong typing
• Traceability
• Explainability

rather than raw implementation mechanics.

---

Information Architecture

Left Navigation

Playbooks

• SQL Statistics Classification
• Taxonomy Extraction & Classification
• Essay Rubric Evaluation

Selecting a Playbook navigates to:

/playbooks/{playbookId}

Examples:

/playbooks/sql-statistics

/playbooks/taxonomy-classification

/playbooks/essay-rubric

---

Playbook Detail Page

Route

/playbooks/{playbookId}

Component

PlaybookPage.razor

This page represents a single Playbook aggregate execution.

---

Page Layout

+------------------------------------------------------+
| Left Navigation |
| |
| SQL Statistics |
| Taxonomy Classification |
| Essay Evaluation |
| |
+------------------------------------------------------+

+------------------------------------------------------+
| Playbook Header |
+------------------------------------------------------+

+------------------------------------------------------+
| CER Workflow Navigator |
| |
| [Collect] -> [Evaluate] -> [Record] |
| |
+------------------------------------------------------+

+------------------------------------------------------+
| Selected Stage Detail |
+------------------------------------------------------+

---

Playbook Header Section

The top section provides execution-level summary information.

Purpose:

Provide enough information so a user understands what happened without drilling into stage details.

Fields

Playbook Name

Example:

SQL Statistics Classification

Description

Example:

Classifies SQL database size using a deterministic rubric.

Execution Date

Example:

2026-10-01 18:42 UTC

Workflow Type

Example:

Deterministic

Agentic

Hybrid

Playbook Status

Example:

Completed

Failed

Cancelled

Duration

Example:

00:00:03

Collect Input Summary

Example:

Database: ProductDb

Final Record Output Summary

Example:

Classification: Medium

---

CER Workflow Navigator

Directly below the header.

Purpose:

Visually reinforce the CER model.

Style:

Three connected workflow cards or chevrons.

Example:

+-----------+ +-----------+ +-----------+
| COLLECT | --> | EVALUATE | --> | RECORD |
+-----------+ +-----------+ +-----------+

Current selection highlighted.

Selected example:

+===========+ +-----------+ +-----------+
| COLLECT | --> | EVALUATE | --> | RECORD |
+===========+ +-----------+ +-----------+

Clicking each node loads stage details below.

---

Collect Detail View

Visible when Collect is selected.

Purpose:

Show exactly what evidence entered and exited the stage.

Fields

Stage

Collect

Tool Name

Example:

SqlDatabaseStatisticsCollectTool

Execution Type

Example:

Deterministic

Start Time

End Time

Duration

Input

Strongly typed serialized summary.

Example:

DatabaseName:
ProductDb

Output

Example:

SizeGb:
38

TableCount:
112

IndexCount:
24

Governance

Replay Supported:
Yes

Execution Id:
abc123

---

Evaluate Detail View

Visible when Evaluate is selected.

Purpose:

Show evaluation inputs, rubric, and resulting finding.

Fields

Stage

Evaluate

Tool Name

Examples:

SqlDatabaseStatisticsEvaluateTool

TaxonomyClassificationAgentTool

EssayEvaluationAgentTool

Execution Type

Example:

Deterministic

Agentic

Input

Evidence summary.

Rubric / Knowledge

Example:

Small <= 20 GB

Medium <= 100 GB

Large > 100 GB

Output

Example:

Classification:
Medium

Reason:
Database exceeds Small threshold.

Governance

Replay Supported:
Yes / No

Model:
GPT-5

Temperature:
0

Execution Id:
xyz123

---

Record Detail View

Visible when Record is selected.

Purpose

Show transformation of findings into display or persistence shape.

Fields

Stage

Record

Tool Name

Example:

SqlDatabaseStatisticsRecordTool

Input

Finding summary.

Output

Materialization summary.

Example:

Database:
ProductDb

Classification:
Medium

Summary:
Database classified as Medium using rubric v1.

Persistence Status

Saved:
True

Materialization Id:
12345

Governance

Replay Supported:
Yes / No

Execution Id:
def456

---

SQL Statistics Example Page

Header

Name:
SQL Statistics Classification

Description:
Evaluates SQL database size using a deterministic rubric.

Workflow Type:
Deterministic

Collect Summary:
ProductDb

Record Summary:
Medium Classification

Navigator

Collect | Evaluate | Record

Stage Detail

User can view:

• Statistics collected
• Rubric thresholds
• Classification result
• Materialized output

---

Taxonomy Classification Example Page

Header

Name:
Taxonomy Extraction and Classification

Description:
Extracts taxonomy concepts and classifies them using a model-backed workflow.

Workflow Type:
Agentic

Collect Summary:
Prompt submitted

Record Summary:
Category and tags generated

Navigator

Collect | Evaluate | Record

Stage Detail

Collect

• Prompt
• Extracted terms

Evaluate

• Taxonomy knowledge
• Categorization reasoning

Record

• Generated summary
• Suggested tags

---

Essay Evaluation Example Page

Header

Name:
Essay Rubric Evaluation

Description:
Scores a

Implementation Architecture and Wiring Guidance

Goal

The purpose of these workflows is not to demonstrate three different business domains. The purpose is to demonstrate that the same strongly-typed CER Playbook contracts can execute through three different orchestration models while preserving governance, replayability, dependency boundaries, and stage contract integrity.

The stage contracts should remain fundamentally consistent across workflows. The primary difference is how each stage implementation is resolved and orchestrated.

---

Shared Architectural Principles

All workflows must:

• Execute through Goodtocode.Agents.Playbook.
• Preserve strongly typed Collect, Evaluate, and Record contracts.
• Avoid JSON, dynamic, object, dictionaries, or untyped payloads between CER stages.
• Produce a real EvaluationGovernanceRecord.
• Return a strongly typed final materialization.
• Support live display of results.
• Support optional persistence through application commands.
• Preserve dependency direction.
• Keep orchestration concerns separate from business logic.
• Keep infrastructure concerns separate from application concerns.

---

Project Boundaries

Core.Application

Contains:

• Queries
• Commands
• Use cases
• Rubrics
• Knowledge contracts
• Evidence contracts
• Finding contracts
• Materialization contracts

Examples:

• SqlDatabaseStatisticsQuery
• GetEssaySubmissionQuery
• TaxonomyKnowledge
• EssayRubric
• SqlDatabaseSizeRubric

Core.Application must not depend on:

• Microsoft Agent Framework
• OpenAI
• Infrastructure implementations

---

Infrastructure.AgentFramework

Contains:

• MAF workflow graph construction
• Agent implementations
• Agent-backed stage tools
• Chat client wiring
• OpenAI integration
• Workflow node orchestration

Examples:

• AgenticCollectTool
• AgenticEvaluateTool
• AgenticRecordTool
• MAFWorkflowExecutor

Infrastructure.AgentFramework may depend on:

• Microsoft.Agents.AI
• Microsoft.Agents.AI.Workflows
• Microsoft.Agents.AI.OpenAI

Infrastructure.AgentFramework should contain all MAF-specific code.

---

Goodtocode.Agents.Playbook

Contains:

• CER contracts
• Playbook execution abstractions
• Tool interfaces
• Step contracts
• Resolver abstractions

Examples:

• ICollectStepTool
• IEvaluateStepTool
• IRecordStepTool
• PlaybookExecutor

Goodtocode.Agents.Playbook must remain:

• Framework agnostic
• MAF independent
• OpenAI independent

---

Workflow Type 1: Deterministic Playbook Execution

Execution Model

Uses:

PlaybookExecutor

Does not use:

• Microsoft Agent Framework
• WorkflowBuilder
• Workflow graphs
• LLM inference

Architecture

Collect

Deterministic tool implementation

↓

Evaluate

Deterministic rubric implementation

↓

Record

Deterministic materialization implementation

Purpose

Demonstrates:

• Framework-agnostic CER execution
• Strong typing
• Deterministic replay
• No external model dependency

Governance Expectations

Collect:

• DeterministicReplaySupported = true

Evaluate:

• DeterministicReplaySupported = true

Record:

• DeterministicReplaySupported = true

---

Workflow Type 2: Fully Agentic CER Workflow

Execution Model

Uses:

• Microsoft Agent Framework
• WorkflowBuilder
• InProcessExecution

All three CER stages are implemented by model-backed tools.

Architecture

Collect Node

Agentic Collect Tool

↓

Evaluate Node

Agentic Evaluate Tool

↓

Record Node

Agentic Record Tool

Graph Shape

Collect

↓

Evaluate

↓

Record

The graph shape must mirror the CER model.

Only tool implementations vary.

Purpose

Demonstrates:

• Agent orchestration
• Agent-to-agent handoff
• MAF workflow execution
• Model-backed collection
• Model-backed evaluation
• Model-backed materialization

Governance Expectations

Collect:

• DeterministicReplaySupported = false

Evaluate:

• DeterministicReplaySupported = false

Record:

• DeterministicReplaySupported = false

Each stage execution should create a governance record.

---

Workflow Type 3: Hybrid CER Workflow

Execution Model

Uses:

• Microsoft Agent Framework
• WorkflowBuilder
• InProcessExecution

Only Evaluate is agentic.

Collect and Record remain deterministic.

Architecture

Collect Node

Deterministic Collect Tool

↓

Evaluate Node

Agentic Evaluate Tool

↓

Record Node

Deterministic Record Tool

Graph Shape

Collect

↓

Evaluate

↓

Record

The graph shape must remain identical to Workflow Type 2.

Only the tool implementation registered for each stage changes.

Purpose

Demonstrates:

• Real-world CER execution
• Deterministic evidence retrieval
• AI-assisted reasoning
• Deterministic materialization
• Tool substitution without changing workflow structure

Governance Expectations

Collect:

• DeterministicReplaySupported = true

Evaluate:

• DeterministicReplaySupported = false

Record:

• DeterministicReplaySupported = true

---

MAF Adapter Placement Decision

Recommended Decision:

Keep MAF graph construction inside Infrastructure.AgentFramework.

Rationale:

• Goodtocode.Agents.Playbook remains permanently framework agnostic.
• No direct dependency on Microsoft Agent Framework is introduced into the shared package.
• Consumers may adopt different orchestration technologies in the future.
• CER contracts remain reusable outside MAF.
• Follows dependency inversion and existing governance boundaries.

Possible Future Extraction:

If multiple repositories begin duplicating identical MAF graph construction logic, consider introducing:

Goodtocode.Agents.Playbook.AgentFramework

This would be a satellite package that references:

• Goodtocode.Agents.Playbook
• Microsoft Agent Framework

The base Playbook package would remain framework independent.

---

Tool Registration Strategy

Each stage implementation should be selectable through resolver configuration.

Examples:

Deterministic:

• SqlStatisticsCollectTool
• SqlStatisticsEvaluateTool
• SqlStatisticsRecordTool

Agentic:

• TaxonomyCollectAgentTool
• TaxonomyEvaluateAgentTool
• TaxonomyRecordAgentTool

Hybrid:

• EssayCollectTool
• EssayEvaluateAgentTool
• EssayRecordTool

The resolver determines which implementation executes.

The Playbook contract remains unchanged.

---

Governance Requirements

Every workflow execution must produce:

EvaluationGovernanceRecord

The record should capture:

• Workflow type
• Stage
• Tool identifier
• Start time
• End time
• Duration
• Replay capability
• Model information when applicable
• Outcome
• Validation status

Governance output must be produced for:

• Deterministic execution
• Fully agentic execution
• Hybrid execution

---

Testing Requirements

Workflow 1

Verify:

• Deterministic CER execution
• Rubric evaluation
• Record transformation
• Failure handling
• Cancellation support
• Governance generation

Workflow 2

Verify:

• MAF graph construction
• Agentic Collect execution
• Agentic Evaluate execution
• Agentic Record execution
• Typed validation
• Governance generation
• Stubbed model responses

Workflow 3

Verify:

• Hybrid graph construction
• Deterministic Collect dispatch
• Agentic Evaluate dispatch
• Deterministic Record dispatch
• Governance generation
• Tool substitution behavior

---

Key Architectural Message

The three examples should teach that the stage contracts remain constant:

Collect -> Evaluate -> Record

The governance model remains constant.

The resolver model remains constant.

The workflow graph shape remains constant.

The only thing that changes is which implementation is selected:

• Deterministic implementation
• Agentic implementation
• Hybrid implementation

This demonstrates that CER is the architectural abstraction while MAF is merely one orchestration strategy capable of executing CER stage implementations.

Workflow 1: SQL Statistics Classification (Deterministic CER)

Purpose

Demonstrate a fully deterministic, framework-agnostic CER workflow with strongly typed contracts, versioned rubrics, deterministic replay support, and no LLM involvement.

Execution Model

Collect: Deterministic

Evaluate: Deterministic

Record: Deterministic

Workflow

Collect

SqlDatabaseStatisticsQuery
->
SqlDatabaseStatisticsEvidence

Evaluate

SqlDatabaseStatisticsEvidence
+
SqlDatabaseSizeRubric
->
SqlDatabaseSizeFinding

Record

SqlDatabaseSizeFinding
->
SqlDatabaseSizeMaterialization

Example

Statistics:

• DatabaseName: ProductDb
• SizeGb: 38
• TableCount: 112

Rubric:

• Small: 0-20 GB
• Medium: 21-100 GB
• Large: 101+ GB

Finding:

• Classification: Medium
• Reason: Database size exceeds Small threshold

Materialization:

• DatabaseName: ProductDb
• Classification: Medium
• SizeGb: 38
• Summary: Database classified as Medium according to rubric v1

Demonstrates

• Strongly typed stage contracts
• Versioned rubric evaluation
• Deterministic replay
• Deterministic record transformation
• Framework-agnostic CER execution
• No MAF dependency
• No LLM dependency

Workflow 2: Taxonomy Extraction and Classification (100% Agentic CER in MAF)

Purpose

Demonstrate a fully agentic CER workflow orchestrated through Microsoft Agent Framework where Collect, Evaluate, and Record are all model-backed tool implementations.

Execution Model

Collect: Agentic

Evaluate: Agentic

Record: Agentic

Workflow

Collect

PromptText
->
TaxonomyExtractionTool
->
TaxonomyEvidence

Evaluate

TaxonomyEvidence
+
TaxonomyKnowledge
->
TaxonomyClassificationTool
->
TaxonomyFinding

Record

TaxonomyFinding
->
TaxonomyMaterializationTool
->
TaxonomyMaterialization

Example

Prompt:

"Customer cannot connect to Azure SQL after a firewall change.
Private endpoint connectivity appears broken."

Collect Output:

Terms:

• Azure SQL
• Firewall
• Private Endpoint
• Networking
• Connectivity

Evaluate Input:

Categories:

• Security
• Networking
• Database
• Identity

Evaluate Output:

Primary Category:

• Networking

Secondary Categories:

• Database

Reasoning:

• Most extracted concepts relate to networking configuration and connectivity concerns.

Record Output:

Title:

• Networking Connectivity Discussion

Summary:

• Discussion centers on Azure SQL connectivity problems associated with firewall and private endpoint configuration.

Suggested Tags:

• Networking
• Azure SQL
• Private Endpoint

Demonstrates

• MAF workflow graph execution
• Agentic Collect stage
• Agentic Evaluate stage
• Agentic Record stage
• Agent-to-agent stage handoff
• Typed validation between stages
• LLM-backed extraction
• LLM-backed classification
• LLM-backed materialization

Workflow 3: Essay Rubric Evaluation (Hybrid CER in MAF)

Purpose

Demonstrate the most common real-world CER pattern where deterministic collection and recording surround an agentic evaluation stage.

Execution Model

Collect: Deterministic

Evaluate: Agentic

Record: Deterministic

Workflow

Collect

GetEssaySubmissionQuery
->
EssayEvidence

Evaluate

EssayEvidence
+
EssayRubric
->
EssayEvaluationTool
->
EssayRubricFinding

Record

EssayRubricFinding
->
EssayScorecardMaterialization

Example

Essay Submission:

"Describe the impact of cloud computing on modern software development."

Rubric Criteria:

• Clarity
• Organization
• Evidence
• Grammar

Evaluate Output:

Clarity:

• Score: 8
• Reason: Ideas are easy to follow.

Organization:

• Score: 7
• Reason: Structure is logical but transitions could improve.

Evidence:

• Score: 9
• Reason: Strong supporting examples provided.

Grammar:

• Score: 6
• Reason: Several minor grammatical issues detected.

Record Output:

Overall Score:

• 30 / 40

Grade:

• B

Criteria Breakdown:

• Clarity: 8
• Organization: 7
• Evidence: 9
• Grammar: 6

Summary:

• Strong submission with good supporting evidence and generally clear communication.

Demonstrates

• MAF workflow graph execution
• Deterministic collection
• Agentic rubric-based evaluation
• Deterministic record transformation
• Strongly typed rubric contracts
• Strongly typed findings
• Structured scoring outputs
• Real-world hybrid CER architecture
• Separation of retrieval, reasoning, and materialization concerns

Summary

Workflow 1

SQL Statistics Classification

Type:

• Deterministic CER

Collect:

• Deterministic

Evaluate:

• Deterministic

Record:

• Deterministic

Purpose:

• Demonstrate framework-agnostic CER execution without LLMs.

Workflow 2

Taxonomy Extraction and Classification

Type:

• Fully Agentic CER in MAF

Collect:

• Agentic

Evaluate:

• Agentic

Record:

• Agentic

Purpose:

• Demonstrate end-to-end MAF orchestration with model-backed stage implementations.

Workflow 3

Essay Rubric Evaluation

Type:

• Hybrid CER in MAF

Collect:

• Deterministic

Evaluate:

• Agentic

Record:

• Deterministic

Purpose:

• Demonstrate the recommended real-world pattern where evidence retrieval and materialization remain deterministic while reasoning and scoring occur through an LLM-backed evaluation stage.