More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Grounded Numbers: AI summaries with no made-up figures

    1

    Language models choose words well and do arithmetic badly, and a wrong number in a report costs more than a dull sentence.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Grounded Numbers: AI summaries with no made-up figures

    Grounded Numbers: AI summaries with no made-up figures

    Example session with this skill installed

    We run a small online shop, Juniper & Vale. Add a monthly sales summary to our admin dashboard,
    written by Claude. The numbers have to be right: nothing Claude makes up should ever reach the
    dashboard. Please include tests.

    • Read your context and instructions
    • Compiled the grounded numbers

    This is the hand-over for the skill's worked example; the run output in it is the example's real
    output. Paste everything inside the block below (not the four-backtick lines) into the Result
    field.

    **Summary**
    
    I added a monthly sales summary that Claude writes and code checks. Every number is computed from
    your orders in code; Claude only writes the sentences and cites the facts each one uses; a verifier
    checks every figure before anything reaches the dashboard. If Claude is slow, fails, or still gets a
    number wrong after two rewrites, a summary built from the same facts is shown instead. 94 tests
    pass, and none of them needs an API key.
    
    **What I built**
    
    | File | What it does |
    | --- | --- |
    | `evidence.py` | Computes October's facts from orders placed up to 31 October, so later orders never change it |
    | `claims.py` | Reads each number and date Claude writes, as written: `$513`, `$0.5k`, `-10.0 points`, `14 October` |
    | `verifier.py` | Checks every line against the facts it cites: value, unit, citation, "up" or "down" |
    | `fallback.py` | The summary shown when Claude cannot be used, built from the same facts |
    | `pipeline.py` | Draft, check, at most two rewrites, a 20-second deadline per call, a final check before publishing |
    | `models.py` | The model interface, plus a fake model for tests |
    | 6 test files | 94 tests: planted errors, rewrites, timeouts, templates, later orders |
    
    
    **A run with a planted mistake.** The first draft said revenue was $521.75 (it is $512.75) and wrote
    a 10-point fall as a percent. Both were caught and sent back, and the rewrite was published:
    
    ```text
    draft: problems - headline: '$521.75' is not in the evidence; the evidence says $512.75; sentences[2]: '10.0%' is written as percent but returning_share_change is in points; the evidence says -10.0 points
    rewrite: ok
    ```
    
    Published headline: "October 2026: revenue up 89% to $512.75".
    
    **When Claude cannot be used**, the dashboard shows:
    
    ```text
    Juniper & Vale, October 2026: revenue $512.75
    Revenue was $512.75, up 89.2% on September 2026 ($271.00).
    There were 10 orders, at an average of $51.28.
    The best day was 14 October 2026, with $179.00 in sales.
    **Desk lamp sold the most:** 4 units for $256.00.
    Returning customers placed 40.0% of orders, 10.0 points lower than in September 2026.
    ```
    
    **Next steps**
    
    1. Point `build_evidence` at your orders table and check its facts against last month's books.
    2. Connect Claude through the model interface (an adapter is in the skill's
       `references/model-calls.md`), keeping the SDK's timeout inside the 20-second deadline.
    3. Run a few real months and read the summaries before turning the feature on for everyone.
    4. Decide on the extras: a second-model check for meaning, and storing each summary's trace.
    

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Language models choose words well and do arithmetic badly, and a wrong number in a report costs more than a dull sentence. This skill teaches your agent to split the work: code computes every number, the model only explains them, and code checks every number the model writes before it reaches a reader. When the model cannot produce a grounded draft, a template built from the same numbers is published instead.

    How it works. The agent follows a workflow in SKILL.md:

    1. List every figure the feature shows, with its formula, source, unit and precision.
    2. Build an evidence pack in code for a period that has ended, so a rerun gives the same numbers.
    3. Ask the model for JSON in which every line cites the facts it uses.
    4. Check every number and date in code: rounding as written ($513 passes for 512.75, $521.75 does not), units (percent is not percentage points), citations and direction words.
    5. Send problems back for at most two rewrites, with a deadline on every model call.
    6. Publish a template built from the same facts on a timeout, an error or a draft that still fails.
    7. Check again just before publishing, and test it all with a fake model.

    It builds a small core by default and adds the rest (date checks, a second-model meaning check, traces) when the request or the stakes call for it.

    Where it stops. The checks prove where each number came from, not what a sentence means: a line can cite the right number for the wrong claim. An optional second-model check and human review cover meaning. Numbers written as words are not checked; the model is asked for digits.

    What's included. SKILL.md; five references (evidence packs, the verifier, fallbacks, model calls with a Claude API adapter, testing); and a worked example, a monthly sales summary for a fictional shop in Python 3.12 with the standard library only, with 94 tests.

    Does not check numbers written as words. Cannot verify semantic meaning without optional step 6. Requires exact matches for whole numbers. Verification is limited to computed facts in the pack.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed today

    Requires

    Anthropic
    ```text
    Python 3.12 or later, for the worked example
    pytest, to run the example's tests
    ```

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Allowed Hosts

    api.anthropic.com

    The skill adds code and tests to your project and runs the tests. It makes no network calls and needs no API key itself; the summaries it builds call your model provider at run time, with its usual credentials.

    Listedtoday

    What's inside

    Frequently Asked Questions

    No. It stops wrong, uncited and badly rounded numbers, unit mix-ups and wrong direction words. It does not judge what a sentence means; the skill describes an optional second-model check for that.

    Any coding agent that reads SKILL.md can use it: Claude Code, Codex CLI, Cursor, GitHub Copilot and Gemini CLI. The feature it builds works with any language model, because the pipeline talks to the model through one small interface. The skill includes an adapter for the Claude API; for another provider, such as OpenAI, Google or a local model, your agent writes a similar adapter. If the provider has a JSON or structured-output mode, use it; the reply is checked in code either way.

    A skill your agent follows, not a library to install. Through Agensi, your agent receives SKILL.md (the workflow), five references (evidence packs, the verifier, fallbacks, model calls with a Claude API adapter, and testing) and a worked example: a monthly sales summary for a fictional shop in Python 3.12, with eight modules and six test files (94 tests). Your agent adapts the example to build the feature in your own codebase.

    Yes. It checks every number and date: the value as written, the unit (percent is not percentage points), that the line cites the fact, and that 'up' or 'down' matches the sign. It does not check meaning. A line can cite the right number for the wrong claim, and a wrong name, an invented cause ('thanks to the sale') or a loose comparison ('nearly doubled' for a 40% rise) still passes. The skill describes an optional second-model check for those. Numbers written as words ('twenty') are not checked, so the model is asked to write digits.

    Your agent does the integration by following the skill's workflow. Most of the work is the first step: listing the figures your text shows and computing each one in code, which your pipeline may already do. The agent then adds the evidence pack, the check, the template fallback and tests around your existing model call. By default it builds a small core and lists the optional parts, so the size of the change depends on how many figures your text uses.

    No. The checks are plain code.

    The workflow is language-independent. The agent ports the example's modules, and the references name the decimal types to use in JavaScript, Java and C#.

    By default it builds the core and lists the optional parts for you to choose.