# Ase Meta Evaluate

> >

- **Type:** Skill
- **Install:** `agentstack add skill-rse-ase-ase-meta-evaluate`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [rse](https://agentstack.voostack.com/s/rse)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [rse](https://github.com/rse)
- **Source:** https://github.com/rse/ase/tree/master/plugin/skills/ase-meta-evaluate
- **Website:** https://ase.tools

## Install

```sh
agentstack add skill-rse-ase-ase-meta-evaluate
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

Evaluate Alternatives

    $ARGUMENTS

*Evaluate* *alternatives* through a weighted
multi-*criteria* decision matrix.

1.  
    -   From the , try to derive the overall
        reason  for the evaluation. If no such reason can be
        derived, assume generic comparison.

    -   Output the determined reason with just the following 
        and do not output anything else:

        
         **REASON**: **
        
    

2.  
    -   From the  derive the two or more
        alternatives  (K=1-N) the user wants to be
        evaluated. Do not output anything.

    -   If fewer than two alternatives could be derived (N and *stop the entire flow* immediately without
        executing any further steps:

        
         **ERROR: INSUFFICIENT ALTERNATIVES**: at least two are required for a comparison!
        

    -   For each alternative  (K=1-N), decide whether
        you have all necessary information at hand to give it the proper,
        unique, short, and *concise name* . If you are
        unsure, use the `ase-meta-search` skill (at most one invocation per
        alternative, drawing from the *skill-wide shared budget* of at
        most 8 `ase-meta-search` invocations in total across STEP 2 and STEP 3
        combined) to find out more and adjust the name .

        If still unsure after the shared budget is exhausted, pick the
        best-guess concise name and proceed. Do not output anything.

    -   For each alternative  (K=1-N), decide which *one*
        of *USP* (Unique Selling Point -- what makes it unique), *Crux*
        (what you should notice), or *Gotcha* (what you should not stumble
        over) is its single most distinguishing perspective, and remember
        this as an  (K=1-N) formatted like `: ` where
         is one of `USP`, `Crux`, or `Gotcha` and  is a 1-6
        word hint. Do not output anything.

    -   For the set of alternatives, decide what the 1-6 word long
        name of the *class of alternatives*  is.
        Do not output anything.

    -   For each alternative  (K=1-N), decide whether
        it is a genuine member of . If any
         is *not* a member (i.e. the alternatives are not
        mutually comparable within a single class), collect the subset
        of non-member alternatives into the space-separated list
         (the  for which the membership
        decision was negative), output the following  and
        *stop the entire flow* immediately without executing any further
        steps:

        
         **ERROR: INCOMPARABLE ALTERNATIVES**: **

        ">
        ⚑ **** (*member of a different class*)
        
        

    -   Output the determined, individual alternatives as a Markdown
        *table* with just the following  and do not output
        anything else:

        
         **ALTERNATIVES**: **

        | ⚑ *Alternative*        | ⚖ *Hint*  |
        | :--------------------- | :-------- |
        | ⚑ **** |  |
        [...alternatives K=2-(N-1) for N>2...]
        | ⚑ **** |  |
        
    

3.  
    -   From the , try to derive the criteria
         (L=1-M) for the evaluation. Do not output anything.

    -   For each criterion  (L=1-M), decide on its 
        from the value set { 4.00, 2.00, 1.00, 0.50, 0.25 } (from most
        important, over normal, to less important). Do not output anything.

    -   Ensure the final number of criteria is always within the range of
        minimum 8 and maximum 12: if fewer than 8 criteria were requested,
        use the set of alternatives to decide on additional criteria
        which potentially allow best to triage the alternatives, take the
         into account, and use the `ase-meta-search` skill (drawing from
        the *skill-wide shared budget* of at most 8 `ase-meta-search` invocations
        in total across STEP 2 and STEP 3 combined) to find out about the
        potentially still missing criteria and assign their .

        If still under 8 criteria after the shared budget is exhausted,
        fill the remaining slots from existing knowledge without further
        searches; if more than 12 criteria were requested, drop the criteria
        with the smallest  until 12 remain. Do not output
        anything.

    -   To prevent a single high-weight criterion from dominating the
        weighted sum (the weight set is geometric ×2 while the evaluation
        Likert scale is linear), assign weight 4.00 to *at least one* and
        *at most two* criteria, and weight 2.00 to *at least two* and *at
        most three* criteria. Symmetrically, to prevent a long tail of
        negligible-weight criteria, assign weight 0.50 to *at most two*
        criteria, and weight 0.25 to *at most one* criterion. Do not output
        anything.
    

4.  
    -   For each alternative  (K=1-N) and each criterion
         (L=1-M), decide on the evaluation , which
        means how well the alternative meets the criterion on a Likert-scale
        from { -2, -1, 0, +1, +2 } (from worst, over neutral, to best). Do
        not output anything.

    -   Then, calculate the ratings  (K=1-N) for all
        alternatives in a single call by invoking the `ase_decision_matrix(matrix:
        [ [ , , ...,  ], ..., [ ,
        , ...,  ] ])` tool of the `ase` MCP server.
        The tool returns an array of N numerical values, where the K-th
        entry is the product-sum of all weights  (L=1-M) and
        the evaluation  (L=1-M) for alternative .
        Retain the *raw, unrounded*  for use in STEP 5, but
        round  to 2 decimal places *for display only* when
        emitting it in the table below. Do not output anything.

    -   Output the resulting *Weighted Decision Matrix* as a Markdown
        *table* with just the following  and do not output
        anything else. When emitting the table, render *one column per
        alternative*  (K=1-N).

        
         **EVALUATION**: *Weighted Multi-Criteria Decision Matrix*

        | ⦿ *Criteria*  | ⚖ *Weight*  | ⚑ **** | [...alternatives 2-(N-1)...] | ⚑ **** |
        | :------------ | ----------: | ---------------------: | ---------------------------: | ---------------------: |
        |  |  |             | [...evals 2-1..(N-1)-1...]   |             |
        [...criteria L=2-(M-1) for M>2...]
        |  |  |             | [...evals 2-M..(N-1)-M...]   |             |
        | **RATING**    |             | ****        | [...ratings 2-(N-1)...]      | ****        |
        
    

5.  
    -   The best alternative  (K=1-N) is the alternative
        whose *raw, unrounded*  (i.e. the product-sum from STEP
        4, *before* the display-only rounding) is the maximum rating value
        across all alternatives. Do not output anything.

    -   The second best alternative  (X=1-N, X != K) is
        the alternative whose *raw, unrounded*  is the second
        largest rating value across all alternatives. Do not output anything.

    -   If multiple alternatives share the second-largest raw rating, pick
        any one of them as ; the resulting  and
         are unaffected by the choice, so the downstream output
        is deterministic. Do not output anything.

    -   Determine rating distance  between  and
         from their *raw, unrounded* ratings by calculating:
         =  - . Do not output anything.

    -   Determine rating distance percentage  between
         and  from their *raw,
        unrounded* ratings as follows. If  is exactly zero,
        skip the division entirely (it is undefined against a zero
        anchor) and classify directly by  instead of routing a
        raw rating magnitude through the ratio thresholds below: if
         is also exactly zero, both best and second best rate
        zero, which is a genuine tie, so set  = 0 to fall
        into the *MULTIPLE BEST* branch below; otherwise  > 0
        means the second best rates strictly negative (since 
        is the maximum), so there is a clear positive gap to a worse
        runner-up and  is an unambiguous winner, hence set
         = 1 (a sentinel exceeding all small-distance
        thresholds) to fall through to the plain *BEST ALTERNATIVE* branch.
        Do not output anything.

    -   Otherwise ( is non-zero), calculate:  =
         / abs(). Do not output anything.

    -   By construction,  is the maximum rating across
        all alternatives, so  >= 0 always holds; using
        abs() keeps  sign-stable across all rating
        regimes. Note that when  itself is negative, the
        denominator anchors to a poor best rating and small gaps can
        appear large; the all-negative regime is surfaced as a dedicated
        warning branch below. Do not output anything.

    -   If  is less than zero (i.e. all alternatives
        rate negatively and the "best" is merely the least-bad), stop the
        flow after you output just the following  and do not
        output anything else. This all-negative check is evaluated *before*
        the small-distance checks below, so that an all-negative alternative
        set with a small winning gap surfaces the all-negative warning rather
        than being masked by the multiple-best or small-distance branches:

        
         **BEST ALTERNATIVE**: ⚑ ****
        ⚠ *ATTENTION: all alternatives rate negatively; this is the least-bad choice, not a strong winner!*
        

    -   Otherwise, if  is less than 0.01 (i.e.  is
        effectively zero relative to abs()), stop the flow after
        you output just the following  and do not output anything
        else:

        
         **ERROR**: ✘ *MULTIPLE BEST ALTERNATIVES FOUND*,
        ⚠ *Please give some hints on the criteria to ensure a single best alternative!*
        

    -   Otherwise, if  is less than 0.10, stop the flow after
        you output just the following  and do not output anything
        else:

        
         **BEST ALTERNATIVE**: ⚑ ****
        ⚠ *ATTENTION: small distance to second best alternative!*
        

    -   Otherwise ( is greater than or equal to 0.10), output
        just the following  and do not output anything else:

        
         **BEST ALTERNATIVE**: ⚑ ****

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [rse](https://github.com/rse)
- **Source:** [rse/ase](https://github.com/rse/ase)
- **License:** Apache-2.0
- **Homepage:** https://ase.tools

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-rse-ase-ase-meta-evaluate
- Seller: https://agentstack.voostack.com/s/rse
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.
