Introducing METIS: Ready-to-Integrate Evals for Agentic Workflows
Evaluating AI agents goes beyond checking their responses. Use METIS, GovTech AI Practice’s open-source evaluation framework, to turn requirements into repeatable tests, simulate realistic interactions, and catch hidden failures before deployment.
AI agents need more than response-based evaluation
Consider an AI agent that assesses grant applications. It retrieves applicant records, checks eligibility, calculates funding amounts and updates a case-management system. The agent produces a convincing assessment: the applicant meets the eligibility criteria and the application is ready for review. Yet its execution trace reveals that it used an outdated policy to calculate funding and approved the application without the required officer authorisation.

The final assessment looks reasonable, but the agent has made critical mistakes along the way.
Conventional LLM evaluations (“Evals”) often assess response quality: accuracy, relevance and safety. Agentic evals must go further. Agents make decisions, invoke tools and execute workflows, introducing failure points beyond the final response.
For our grant-processing agent, we need to ask:
- Did it retrieve the correct records and apply the latest eligibility criteria?
- Did it extract information and calculate the funding amount accurately?
- Did it invoke the appropriate tools and handle errors correctly?
- Did it follow the approval workflow without bypassing human oversight?
Agent behaviour is also dynamic. Applicants may submit incomplete documents, provide conflicting information or change their requests midway. External systems may fail, requiring agents to adapt.
Evaluating agents therefore requires testing their actions and outcomes across realistic, multi-step scenarios, not simply grading their final responses.
The need for a new evaluation framework
For most teams, the hardest step comes at the start: deciding what to evaluate. Requirements for agentic systems often sit in product specifications and policy documents, and are often epistemic: what good means for your product is living in your head.
Existing evals frameworks offer valuable capabilities, with two common approaches:
- Metric-driven evals use predefined metrics to assess qualities such as response correctness, task completion and tool usage. Frameworks such as DeepEval and MLFlow support these evaluations. Generic metrics provide useful baselines but may overlook application-specific requirements, such as mandatory approvals or policy restrictions. Custom metrics such as G-Eval and Arize let teams write their own criteria, but this assumes that they know precisely what to evaluate, which can be challenging given the complexity of agentic systems.
- Error-driven evals use observed failures and execution traces to identify problems and build regression tests. Platforms such as Braintrust and LangSmith support this approach. Production failures provide valuable evidence for regression testing. But relying on them creates a cold-start problem: teams need to identify risks before those failures occur in production.
Both approaches are useful, but high-stakes government applications demand more than generic metrics or failures discovered after deployment. Before agents interact with real-world systems, teams must evaluate them against explicit operational, policy and safety requirements. This provides a stronger basis for assessing risks, demonstrating accountability and building confidence among citizens and stakeholders.
Specification-driven evals address this need by starting with application requirements. Teams define features and expected behaviours, translate them into measurable criteria and test whether agents meet those criteria. Existing frameworks can support parts of this process. The challenge is bringing everything together into a practical workflow, particularly when:
- Evals extend beyond text. Agents generate reports, charts and other artefacts that may also require assessment.
- Domain experts need to participate. Product managers and policy officers understand operational requirements but may lack the technical skills to build eval pipelines.
- Requirements are context-specific. Government applications must meet applicable governance and security requirements. GovTech's Agentic Standard sets out requirements for developing and deploying agentic systems across government, including risk assessments and approval processes. Teams need to translate relevant requirements into testable behaviours.
Introducing METIS: From requirements to repeatable evaluations
METIS (Measurement and Evaluation of Trustworthy Intelligent Systems) differentiates itself from existing frameworks by uniting specification design, realistic simulations and execution-level grading into a single, cohesive framework.
METIS addresses four key challenges in agentic evaluations:
- Testing against domain-specific requirements. METIS translates application requirements into measurable criteria, testing whether agents follow prescribed workflows, invoke tools correctly and achieve expected outcomes.
- Identifying failures before deployment. METIS simulates multi-turn interactions using realistic user personas and scenarios, helping teams identify failures in a controlled environment before exposing users to them.
- Evaluating the full execution trajectory. A correct final response can conceal mistakes along the way. METIS uses curated graders and integrations with observability platforms such as Langfuse to assess recorded tool calls, intermediate actions and outputs. Its grader library supports testing of selected risks highlighted in IMDA's Model AI Governance Framework for Agentic AI, helping teams detect failures beyond response quality.
- Test against government operating requirements. METIS helps teams encode government policies, governance standards and approval procedures into evaluation criteria, making these requirements testable rather than implicit.
How METIS works
METIS follows four core steps from our Evaluation Playbook: Define, Design, Execute and Improve. This approach aligns with IMDA's Starter Kit for Testing Agentic Systems for Safety and Reliability, which similarly emphasises identifying risks, designing realistic tests, analysing execution logs and continuous retesting.

To operationalise this four-step methodology, we built and open-sourced METIS. At its core, the software toolsuite comprises three primary components - Wizard (for Define & Design), Engine (for Execute), and Insights (for Improve) - supported by an extensible Library.

Wizard powers the Define and Design steps by translating application requirements into expected agent behaviours and measurable criteria. Anchored by GovTech's Agentic Risk & Capability (ARC) Framework, it assesses capabilities such as tool use, code execution, and data access to guide test design. The output is a structured evals specification defining simulation parameters (e.g., test scenarios, personas) and the prescribed graders.

Engine powers the Execute step by running multi-turn simulations against the specification, instrumenting execution traces and capturing agent responses. It connects to target agents across multiple interfaces, from standard HTTP APIs to web UIs via automated browser interaction. Engine orchestrates the eval itself - invoking prescribed graders to judge agent behaviour against the defined criteria.

Insights powers the Improve step by compiling a report from the grader results, supported by evidence. Teams can investigate failures, refine their agents or test criteria, and rerun evals to measure improvements. The report can also be exported as machine-readable JSON for downstream pipelines and CI/CD integration.

Library provides a modular suite of graders that are callable by Engine during the judging phase. Each grader maps to a taxonomy synthesised from established industry benchmarks and operational experience, ensuring comprehensive coverage across safety, reliability, and capability dimensions.
Get started with METIS

Whether you are building your first eval or improving an existing pipeline, METIS offers different ways to get started.
- No-Code Web UI for Product Managers, Policy Officers and Domain Experts.
Use an interactive interface to define expected behaviours, develop eval specifications, explore test suites and examine execution traces. Non-technical stakeholders are encouraged to be part of the eval process lending expertise and contextual knowledge of the product’s use case and users.
- Python Package and CLI for Developers and AI Agents.
Import METIS into Python projects or run evals locally through command-line tools. Its programmatic interfaces also allow AI coding assistants and automated test runners to invoke METIS, supporting agent-assisted eval workflows.
- REST API and CI/CD Integration for Platform Teams.
Integrate METIS into automated testing pipelines through its REST API. Run regression evals before code changes reach staging or production, helping teams detect failures as agents evolve.
Start with one critical workflow. Define its requirements, test your agent against realistic scenarios and use the results to guide improvements. Expand your eval coverage as your agent evolves.
We welcome feedback and contributions through GitHub or at aipractice@tech.gov.sg.
Over the coming months, keep an eye on this space as we share more real-world METIS deployment stories and use cases from across the Singapore public sector.