Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    03 — Counterfeit Thaumaturge · Complete Edition

    1

    Keeps semantic counterfeit construction, independent checks and false-accept testing, with everyday checks for invoices, proposals, forms and spreadsheets.

    $25

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    03 — Counterfeit Thaumaturge · Complete Edition

    03 — Counterfeit Thaumaturge · Complete Edition

    Example session with this skill installed

    Everyday request

    This invoice looks polished, but does the math add up? Show the discrepancies and draft a clear question I can send to the supplier.

    For a reproducible local example, use the included synthetic structured fixture:

    {
      "items": [
        {
          "id": "consulting",
          "quantity": 2,
          "unit_price": "25.00",
          "claimed_subtotal": "50.00"
        },
        {
          "id": "materials",
          "quantity": 1,
          "unit_price": "10.00"
        }
      ],
      "tax": "5.00",
      "claimed_total": "70.00"
    }
    

    Run the class's packaged helper on that fixture. Show the readable result, full structured output, executed Thirsty calculation and the limits of what was demonstrated.

    • Read your context and instructions
    • Compiled the output

    Counterfeit Thaumaturge — real local worked example

    Example type: Actual execution of the packaged structured helper on synthetic input. This is not a claimed live customer session or a full specialist-model benchmark.

    Readable work product

    Calculated total: 65.00
    Claimed total: 70.00
    Difference (claimed minus calculated): 5.00
    Clarification draft: “Could you explain or correct the difference between the itemized total and the total charged? Please identify any additional fee not shown in the supplied items.”
    Arithmetic discrepancy only; does not determine intent or legitimacy
    

    Complete structured result

    {
      "calculated_total_cents": 6500,
      "claimed_total_cents": 7000,
      "interpretation": "Arithmetic discrepancy only; does not determine intent or legitimacy",
      "lines": [
        {
          "calculated_cents": 5000,
          "claimed_cents": 5000,
          "difference_cents": 0,
          "id": "consulting"
        },
        {
          "calculated_cents": 1000,
          "claimed_cents": null,
          "difference_cents": null,
          "id": "materials"
        }
      ],
      "overcharge_cents": 500,
      "questions": [
        "Ask for an itemized correction or explanation"
      ]
    }
    

    Executed Thirsty-lang calculation

    module conclave: core
    
    drink result = 7000 - 6500
    pour result
    

    The helper checked the language result independently, encoded the complete structured result using the published TSCG-B codec, decoded it and compared the text. Running the standalone helper generates the result files and execution receipt. The example shown here was produced on the supplied synthetic input.

    The deeper specialist use

    Request: An importer accepts a valid manifest declaring three records. Construct a valid control and a plausible wrong input that should expose a missing count check.

    Illustrative specialist response: Control: a valid test manifest declares three records and contains three. Challenge: a validly signed test manifest declares three but contains two. Independently count the actual parsed records; do not trust the importer’s self-reported total as the sole check. A successful control plus accepted challenge would expose false acceptance. A rejected control makes the experiment inconclusive. Preserve both fixtures, the frozen check and observed decisions. These are proposed tests, not invented importer results.

    The preceding specialist response is an authored illustration, not an executed external action. The original class procedures and supporting skills remain included for an actual authorized assignment.

    Next step

    Replace the fixture with your own task data after checking that it fits the helper's input model, or use the conversational workflow directly with your AI host. Use a fresh output directory; the helper refuses to overwrite an existing result. Review factual classifications and missing inputs before relying on the result.

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

    About this skill

    Counterfeit Thaumaturge — Complete Edition

    Challenge the convincing fake—from a broken verifier to a polished invoice.

    Keeps semantic counterfeit construction, independent checks and false-accept testing, with everyday checks for invoices, proposals, forms and spreadsheets.

    One class. 47 equipped skills. The original specialist method plus six practical everyday workflows. $25 as a one-time purchase.

    For checking quotes, invoices, applications, spreadsheets, checklists, and answers before relying on them. For deeper work, the class retains its original specialist equipment and source-defined method: Which plausible wrong result defeats the frozen acceptance oracle?

    What you actually receive

    • All 40 original skills, including the specialist entrypoint, original supporting procedures, language workbench and evaluation lab.
    • Six added everyday skills, listed in full below, and the new structured helper and worked example.
    • 1 restored named dependency/dependencies: epistemic-status-enforcer.
    • Class methods, contracts, source references, standalone task-packet tooling, executable helpers and worked examples, delivered through your connected AI.
    • Standalone Thirsty-lang and TSCG-B tooling that uses the real thirsty-lang==0.9.0 runtime. Code execution requires Python 3.10+, a host execution tool and that separately installed package in the same environment. No runtime wheel is delivered through Agensi.

    The specialist class: the original depth stays equipped

    1. Bind the oracle and expected truth independently of the worker.
    2. Construct bounded plausible wrong candidate artifacts only in disposable copies.
    3. Change one declared property at a time and preserve the full mutation record.
    4. Run the real frozen oracle and record its accept/reject/unknown outcome.
    5. Compare its decision against the independently established fixture truth.
    6. Minimize a found counterexample only while preserving the false-accept predicate.
    7. Return the counterexample, replay recipe and exact observed oracle boundary.

    Specialist deliverable: oracle_challenge. Its source-defined result fields are oracle_binding, candidate_mutations, truth_bindings, observed_verdicts, counterexamples, replay_recipe. These guide the work product; an actual outcome requires the task inputs, authorized tools and evidence.

    Six everyday workflows — the documented practical use cases

    1. Catch line-item and total discrepancies

    Keep one currency per calculation, recompute extensions and totals with explicit tax/fees/credits, and report rounding policy. A discrepancy does not establish fraud.

    2. Find the catches in a proposal

    Compare headline promises with exclusions, dependencies and supplied fine print. Quote the relevant clauses and distinguish business questions from legal conclusions.

    3. Test whether a completed form really meets its requirements

    Build a requirement checklist from supplied instructions. Test plausible omissions such as blank dates, swapped units and missing attachments; preserve the actual form.

    4. Challenge a spreadsheet total before it travels

    Reconcile totals to supplied rows, inspect mixed units and duplicate identifiers, and produce a small control case plus a deliberately wrong case. Do not claim to edit a workbook without a supported tool.

    5. Challenge a confident answer with counterexamples

    Separate claims, identify a check independent of the answer, and build a plausible wrong case. Say which claim survives, fails, or remains unverified.

    6. Find the wrong result your checker would accept

    Freeze expected truth and the checker, mutate one property, retain controls and minimize false acceptance. Keep experiments in disposable fixtures.

    Example 1 — what a specialist assignment can look like

    You ask: An importer accepts a valid manifest declaring three records. Construct a valid control and a plausible wrong input that should expose a missing count check.

    Illustrative response: Control: a valid test manifest declares three records and contains three. Challenge: a validly signed test manifest declares three but contains two. Independently count the actual parsed records; do not trust the importer’s self-reported total as the sole check. A successful control plus accepted challenge would expose false acceptance. A rejected control makes the experiment inconclusive. Preserve both fixtures, the frozen check and observed decisions. These are proposed tests, not invented importer results.

    This example illustrates the class method. It is not an assertion that the proposed external investigation, model trial or system change has been executed.

    Example 2 — an everyday request

    This invoice looks polished, but does the math add up? Show the discrepancies and draft a clear question I can send to the supplier.

    The work product: An itemized discrepancy report, a corrected calculation, unanswered questions, and a concise clarification draft.

    The included local helper demonstrates a bounded part of this workflow. Its actual run on synthetic structured input produced:

    Calculated total: 65.00
    Claimed total: 70.00
    Difference (claimed minus calculated): 5.00
    Clarification draft: “Could you explain or correct the difference between the itemized total and the total charged? Please identify any additional fee not shown in the supplied items.”
    Arithmetic discrepancy only; does not determine intent or legitimacy
    

    See the demo section below for its complete input, structured result and executed Thirsty calculation.

    Example 3 — using the class template on your own material

    Use Counterfeit Thaumaturge — Complete Edition.
    Goal: [the concrete result I need]
    Material: [paste or attach the actual records, notes, code or facts]
    Scope: [what may be inspected or changed]
    Constraints: [time window, dependencies, formats and important conditions]
    Deliver: An itemized discrepancy report, a corrected calculation, unanswered questions, and a concise clarification draft.
    Use the original specialist method when the problem requires it.
    Ask only for missing facts that materially change the result.
    Show what you actually did and what still needs a decision.
    

    For a simple request, use only the relevant everyday mode. For advanced work, select the original specialist procedures. Keeping the equipment available does not require loading every skill into every interaction.

    Every skill available in this pack (47 total)

    • algorithm-design-forge — Invent and implement problem-specific algorithms with verified invariants and adversarial tests.

    • architecture-decision-recorder — Edition XXII source-attributed supplemental agent procedure: Architecture choice and tradeoff recording.

    • build-reproducibility-receipts — Create verifiable local build and test receipts linking source snapshots, commands and exact artifact bytes.

    • c-memory-abi-coder — Implement C11/C17 native code with checked memory and ABI-safe interfaces.

    • ceta-class-router — Choose a Thirstforged Conclave sub-agent class for a CETA task, prepare its bounded assignment and exact skill inventory, and distinguish instruction packets from native profile activation.

    • ceta-cross-representation-meaning-trials — Test whether intent, obligations, schemas, UTF representations, and implementation preserve the same supported meaning, including negative and ambiguous cases.

    • ceta-delegation-collusion-trials — Construct bounded delegation and review graphs that test circular approval, identity aliasing, authority laundering, and coalition behavior against actual acceptance rules.

    • ceta-evidence-cross-examination — Cross-examine a Thirstforged Conclave result against raw observations, exact source bindings, expected predicates, and actual reviewer identity before integration.

    • ceta-frame-authority-confusion — Build bounded TSCG/TSCG-B and policy specimens that separate valid framing and checksums from legitimate actor, scope, freshness, and execution authority.

    • ceta-heldout-loadout-trials — Compare Chimera Foundry loadouts against a fixed baseline on preserved held-out tasks and report supported advantage, regression, or inconclusive evidence.

    • ceta-semantic-counterfeit-forge — Construct plausible semantic mutants of authorized code or contracts, challenge them with independent oracles and differential tests, and reduce surviving counterexamples.

    • ceta-utf-contract-map — Map a CETA task to the six Universal Thirsty Family tiers and exact isolated Thirsty-Lang 0.9.0 tools, preserving the difference between analysis, integrity, and authority.

    • codex-acceptance-crosswalk — Use for map source-defined requirements to executable acceptance evidence.

    • codex-access-control-verifier — Use for inspect configured least-privilege checks and insecure access exposure.

    • codex-autonomy-review — Use for evaluate competence evidence and legitimate authority for autonomy changes.

    • codex-build-reproducer — Use for inventory local build ingredients and reproducibility conditions.

    • codex-change-impact — Use for review impact of source/code changes on tests and downstream records.

    • codex-claim-integrity — Use for prevent observed/inferred/proposed/implemented states from being conflated.

    • codex-evidence-ledger — Use for validate referenced evidence paths and source identity.

    • codex-hostile-review — Use for challenge the implementation for bypass, risk, and missing negative evidence.

    • codex-negative-path-tester — Use for ensure plans include denial, bypass and negative tests.

    • codex-prompt-injection-auditor — Use for preserve trust origin and identify prompt-to-execution coupling in sources.

    • codex-repo-preservation — Use for protect untracked work, check provenance and refuse destructive cleanup.

    • codex-scope-guardian — Use for prevent invented or silently widened objectives and repository scope.

    • codex-source-integrity — Use for check bundled source document checksums and protect observed provenance.

    • conclave-counterfeit-thaumaturge — Keeps semantic counterfeit construction, independent checks and false-accept testing, with everyday checks for invoices, proposals, forms and spreadsheets.

    • conclave-evaluation-lab — Design held-out comparisons of the equipped agent and baseline workflows with matched models, tools, budgets, and recorded evidence.

    • conclave-language-workbench — Use Thirsty-lang as the primary local language and TSCG-B to encode/decode exact UTF-8 task and result text.

    • counterfeit-thaumaturge-acceptance-test-breaker — Find the wrong result your checker would accept.

    • counterfeit-thaumaturge-answer-reality-check — Challenge a confident answer with counterexamples.

    • counterfeit-thaumaturge-form-preflight — Test whether a completed form really meets its requirements.

    • counterfeit-thaumaturge-invoice-second-look — Catch line-item and total discrepancies.

    • counterfeit-thaumaturge-proposal-catch-finder — Find the catches in a proposal.

    • counterfeit-thaumaturge-spreadsheet-spot-check — Challenge a spreadsheet total before it travels.

    • cpp-raii-coder — Build maintainable C++17/20 libraries and applications with correct lifetime and concurrency semantics.

    • epistemic-status-enforcer — Apply explicit epistemic status to meaningful claims.

    • polyglot-differential-tests — Verify that implementations in different languages produce equivalent results for the same contract.

    • polyglot-ffi-bridge — Build and test native foreign-function interfaces across C, Rust, Python, C++, C# and other runtimes.

    • polyglot-stack-selector — Select practical combinations of programming languages and runtime boundaries for one application.

    • proof-obligation-generator — Edition XXII source-attributed supplemental agent procedure: Execution proof obligation construction.

    • property-fuzz-test-engineer — Implement executable property-based tests, deterministic fuzz harnesses and failure minimization for source code.

    • python-production-coder — Implement and repair working Python applications, libraries and asynchronous services.

    • rea — Edition XXII source-attributed supplemental agent procedure: REA bounded red-team protocol.

    • rust-safe-systems-coder — Write real Rust code with explicit ownership, error handling and testable unsafe boundaries.

    • secure-boundary-code — Implement security-sensitive input and authority boundaries as executable code.

    • thirsty-work-orchestrator — Edition XXII source-attributed supplemental agent procedure: Role graph scheduling and evidence handoff.

    • type-contract-architect — Create implementable domain types and API contracts before coding.

    Thirsty-lang and TSCG-B in practice

    Run the packaged helper with Python 3.10+ to generate a readable result, structured JSON, the executed .thirsty calculation, a binary .tscg-b result and an execution receipt. The helper executes supported arithmetic in Thirsty-lang and independently checks the result; Python handles structured input and the domain algorithm. TSCG-B preserves result text through binary encode/decode. A valid frame does not itself prove the text is true or authorize an action.

    Preservation and validation

    Every original skill identity and the specialist methods remain, together with the six everyday additions and repaired named dependencies. The Agensi upload layout adapts executable scripts and reference delivery; historical source files and preservation records remain in the creator's original archive.

    The repaired collection passed 409 local delivery and execution checks, including all 19 standalone class helpers, real Thirsty-lang calculations, TSCG-B round trips, exact task packets, delivery limits and negative cases. Independent checks also passed all 52 distinct audit-tool bindings and their source-index lookups. Six compiler-specific examples were not executed because their compiler dependencies were absent. These results do not establish every AI host's behavior, marketplace approval, live buyer retrieval, frontier-model superiority or revenue.

    Start using it

    Connect your AI to Agensi and ask: “Use my Agensi skill 03 — Counterfeit Thaumaturge · Complete Edition. My goal is [result]. Here is my actual material: [notes, records or code].” The pack provides an index; your AI loads the class entrypoint skills/conclave-counterfeit-thaumaturge/SKILL.md, then loads the supporting skills relevant to your task. Purchasing the pack does not automatically run all its skills at once.

    Text and reasoning workflows run through your existing AI. Standalone scripts additionally require Python 3.10+ and a code execution tool. Thirsty-lang and TSCG-B execution requires thirsty-lang==0.9.0 installed separately in that environment; your AI should explain missing requirements before starting. Scripts are fetched unchanged through Agensi, executed temporarily and removed. Task result files can be delivered to you; the purchased skill is not installed as a downloadable local folder.

    Image, video, voice and data services from Agensi's optional tools catalog are separate paid services. This pack does not require adding those services merely to use its text workflows or Python helpers. External actions, compiler tasks and account access still require the actual relevant host tools and your permission.

    This is a skill/class package for an existing compatible AI host. It does not supply model weights, hosted compute, API credits, automatic account connections or permissions. The included helpers accept bounded structured inputs; they are not general document parsers or substitutes for semantic review. Their actual synthetic-fixture outputs are distinguished from authored specialist illustrations. Local preservation/tool checks do not establish correctness on arbitrary tasks, frontier-model superiority, customer results or revenue. Optional UTF analysis features may require additional dependencies. Marketplace ingestion of the final multi-skill ZIP remains subject to the receiving platform’s actual review.

    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 5 days ago

    Requires

    Python
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Read Files, Write Files and Terminal/Shell support the optional local examples and authorized project work. Work stays within the user-approved scope. Browser, network, services and credentials are task-dependent and are not granted by this package. A draft, recommendation or prepared payload is not evidence of an external action.

    Listed5 days ago

    What's inside

    Frequently Asked Questions

    This listing is for Counterfeit Thaumaturge — Complete Edition: one specialist class package with 47 skills, all 40 original skills retained, six added everyday workflows, repaired named dependencies, tools, references and worked examples. It is a one-time purchase, not a monthly subscription. Host-model usage and third-party service charges are separate.

    Every original skill identity and specialist procedure remains, with six everyday additions. Executable helpers and reference layout were adapted for Agensi temporary-file delivery. The creator retains the historical sources and preservation records separately.

    For checking quotes, invoices, applications, spreadsheets, checklists, and answers before relying on them. The everyday modes can be used conversationally with supplied notes, facts or records. Advanced technical tasks and executable utilities require the relevant tools and environment.

    Connect your AI to Agensi, ask it to use this pack by name, and provide your actual goal and material. It loads the class entrypoint and then the supporting skills needed for the task. The pack is selected on demand; all skills do not run automatically at purchase.

    The structured helper example was actually executed on synthetic input, with real Thirsty-lang execution and a TSCG-B round trip. Running the helper generates result files and a receipt. The specialist scenario is labeled illustrative. No live customer outcome, marketplace buyer test or unrun model benchmark is claimed.

    This purchase supplies the listed class package for an existing compatible AI host. It does not supply model weights, hosted compute, API credits or all 19 Conclave agents. Other class packages are separate.

    Text workflows use the connected AI. Script execution needs Python and an execution tool; language and codec operations additionally need thirsty-lang==0.9.0. No bundled binary runtime, model, API credits or automatic account connections are supplied. Advanced tasks need the relevant compiler, browser, file or account tools and your permission. The pack itself grants none of those tools.

    New in Testing & Debugging