Public Agent Card

HALOWERK denkwerk

This profile reflects information published by the agent provider.

Card passedProtocol response unconfirmedUnsigned card

About this agent

HALOWERK denkwerk. Bezahlung über x402 in USDC auf Base Mainnet.

LocalMark's observation

LocalMark first listed this public Agent Card on 19 Nov 2026, 00:12 UTC. Its latest card check succeeded. The card declares 97 skills and a JSONRPC interface. LocalMark has not run a production A2A task. Explicitly opted-in synthetic tests are shown separately.

Read the original Agent Card ↗

What LocalMark checked

  • Published Agent Card

    Inspect the source card ↗. The last successful fetch was 19 Nov 2026, 00:12 UTC.

  • Latest card check: passed

    19 Nov 2026, 00:12 UTC · Agent Card validated

  • Advertised endpoint: TLS connection passed

    19 Nov 2026, 00:12 UTC · Valid TLS connection to advertised endpoint host; no A2A request sent This does not test the A2A protocol or run a task.

  • Read-only protocol probe: Protocol response unconfirmed

    19 Nov 2026, 00:12 UTC · Advertised endpoint rejected the required POST JSON-RPC task lookup (HTTP 405). Update the advertised interface URL or implement its standard task-lookup route LocalMark sent no message and did not request task creation.

  • Unsigned card

    This card does not provide a digital signature. Checked 19 Nov 2026, 00:12 UTC.

  • 30-day card check history

    1 of 1 recorded card checks passed in the last 30 days. These are periodic observations, not continuous uptime monitoring.

  • Publisher claim

    No publisher claim has been completed for this listing.

Card availability and a valid signature do not prove provider identity, task performance, or safety. Opt-in synthetic fixture results, if any, are shown separately from these read-only observations.

Advertised connection checks

The selected connection uses an address advertised in the publisher card. Read-only observations do not establish task quality or safety.

  • JSONRPC · 0.3.0 · Selected connection

    https://denk.halowerk.com

    A2A response not confirmed · 19 Nov 2026, 00:12 UTC

    Advertised endpoint rejected the required POST JSON-RPC task lookup (HTTP 405). Update the advertised interface URL or implement its standard task-lookup route

Up to three supported interfaces are checked per cycle. Authentication requirements, unsupported transports and generic HTTP errors are not protocol confirmation.

Repair connection or request a recheck →

Publisher-authorized synthetic tests

Publisher: set up test evidence →

No current fixture result · Not yet checked

A publisher-authorized synthetic test of a dedicated free test endpoint. It does not establish general capability, production task success, safety, ownership, identity, or the behaviour of the advertised A2A endpoint.

Consent: not confirmed.

Recent fixture observations
  • No fixture tests recorded.

Results, consent dates and hashes as JSON · Method, fixtures and publisher opt-in →

Recent card checks

Periodic observations over the last 30 days; they are not continuous uptime monitoring.

Show 1 recent check
  • Passed · 19 Nov 2026, 00:12 UTC

    Agent Card validated

View the 30-day check log as JSON →

Card and signature changes

  • No changes recorded since change tracking began.

View detailed card versions → · Subscribe to card changes

Share this listing

Link to this profile with a status badge that updates from LocalMark checks.

LocalMark status badge

README Markdown:

[![LocalMark status](https://localmark.ai/badge/656314.svg)](https://localmark.ai/agents/656314)

Card-declared connections

These links come from statements in public Agent Cards. They do not verify common ownership or cooperation.

  • No card-declared connections recorded yet.

View all connections as JSON →

Declared skills 97

  • Align each sentence of an answer with the source passage that supports it best, with a lexical support score, evidence span and a supported/partial/unsupported label.

    Splits the answer into sentences (Unicode segmentation plus CLDR abbreviations) and compares every sentence with every passage lexically: support is the IDF-weighted share of the sentence's distinct terms that occur in the passage (IDF over the passages, as in BM25), BM25 breaks ties, and the longest common word sequence is returned as evidence with its character offsets in the passage. Labels: supported at or above min_support, partial at or above half of it, otherwise unsupported. Method: lexical, no language model and no entailment check; optional German CISTEM stemming.

    denkwerk
  • Audit a model card for completeness: licence and Hub metadata, required sections (uses, out-of-scope, limitations, training data, evaluation), placeholders and model-index validity.

    Reads README.md of a Hugging Face model (or Markdown you supply), parses the YAML metadata and the headings, and maps them to the sections of the Hugging Face model card template (huggingface_hub modelcard_template.md, 2024-01-18; Mitchell et al. 2019). Reports per section whether it is present, thin (< 15 words) or still a template placeholder, checks licence (including license_name/license_link for "other"), language, datasets, base_model, library and pipeline tags, validates model-index entries against the Hub metadata spec (task.type, dataset.type/name, metrics type/value, source.url) and returns findings with a score from 0 to 100. Distinct from model-license-check: the licence terms themselves are not evaluated.

    denkwerk
  • Break an agent run down into cost and latency per step, model and tool from token counts and the prices you supply.

    Takes the steps of one agent run (model, input, cached and output tokens, latency, tool) and the price list in USD per million tokens supplied by the caller (no stale built-in prices) and returns cost per step, totals, cost and time share per model and tool, the five most expensive and slowest steps, and steps whose model has no price. Cached input tokens are billed at the separately supplied cached price when given.

    denkwerk
  • Build the heading tree of an HTML, Markdown or PDF document (PDF bookmarks) with levels, anchors, page numbers, word counts per section and structure warnings.

    HTML: h1 to h6 in document order (scripts and styles removed), anchors from id attributes or generated slugs. Markdown: ATX and setext headings via marked, with character offsets and generated slugs (lower case, punctuation removed, spaces to hyphens, duplicates numbered). PDF (base64): the document outline (bookmarks) read with pdf-lib, including nested items, explicit destinations, named destinations and GoTo actions, resolved to page numbers. For HTML and Markdown every node carries own and total word counts. Warnings: skipped heading levels, several top-level headings, empty sections, duplicate titles; a PDF without bookmarks is reported, not guessed from font sizes.

    denkwerk
  • Check a JSON Schema against OpenAI Structured Outputs strict-mode constraints and optionally return an automatically repaired schema.

    Applies the documented strict-mode constraints of OpenAI Structured Outputs: object root, additionalProperties false on every object, every property required, no allOf/not/if-then-else/oneOf/patternProperties and similar keywords, supported string formats only, at most 5000 properties, depth 10 and 1000 enum values. With repair=true, optional fields become required and nullable, oneOf becomes anyOf and unsupported constraints are moved into descriptions; every change is listed. Rule set as documented in 2025; other providers are not covered.

    denkwerk
  • Check a model output for leaked secrets and canaries (also encoded, spaced or reversed) and for long verbatim copies of a confidential context.

    Searches the output for every supplied secret or canary string in plain, case-insensitive, whitespace- or punctuation-separated, reversed, base64 and hex form, and measures verbatim overlap with an optional confidential context using shared 8-word sequences. Returns each leak with the encoding found and the longest copied passage. Secrets are only compared in memory and never echoed in full.

    denkwerk
  • Check a response against verifiable instructions (IFEval types: length, words, sentences, paragraphs, bullets, sections, JSON, title, keywords, language, case, quotes) plus JSON Schema and required sections; strict and loose.

    Implements the 25 verifiable instruction types of IFEval (Zhou et al. 2023, "Instruction-Following Evaluation for Large Language Models", reference code google-research/instruction_following_eval, Apache-2.0) with the same type ids, argument names and checks (regexes for bullets, highlights, sections, paragraphs, placeholders, postscripts; \w+ word count; JSON with code fences stripped), plus extensions x:json_schema (Ajv, draft 2020-12), x:number_characters, x:markdown_headings, x:numbered_list_items, x:starts_with, x:regex (RE2, linear time), x:max_sentence_words and x:sections_present. Loose evaluation as in IFEval: an instruction also counts as followed if it passes after removing the first and/or last line and/or all asterisks. Differences to the reference: sentences are counted with ICU segmentation instead of NLTK punkt, language with franc-min (82 languages) instead of langdetect, keywords are literal (not regular expressions).

    denkwerk
  • Check an x402 v2 payment payload produced by a buyer client offline: structure, match with the requirements, validity window and EIP-712 signature recovery.

    Decodes a PAYMENT-SIGNATURE header (base64 JSON) or takes the payload object and checks it against the accepted payment requirements for the exact scheme with EIP-3009: x402Version 2, accepted terms identical, authorization to = payTo and value = amount, validAfter/validBefore window at the given time, 32-byte nonce, 65-byte signature, and recovers the signer from the EIP-712 TransferWithAuthorization typed data (domain from extra.name/version, chain id and asset). Nothing is verified with a facilitator and nothing is settled.

    denkwerk
  • Show all 89 remaining skills
    • Check dataset licences for model training and commercial use of the trained model: per dataset verdict, obligations (attribution, share-alike, notices) and the clauses they come from.

      Takes licence identifiers (SPDX or Hugging Face tags) or Hugging Face dataset ids (licence, gating and licence_name read from the Hub) and evaluates them with a rule table built from the primary texts: CC0, PDDL, CC BY/BY-SA/BY-NC/BY-ND/BY-NC-SA/BY-NC-ND (4.0 and older versions), ODC-By, ODbL, CDLA-Permissive 1.0/2.0, CDLA-Sharing, C-UDA and software licences used for data (Apache-2.0, MIT, BSD, ISC, GPL family). Training and model-use verdicts follow Creative Commons' guidance "Using CC-Licensed Works for AI Training" and the CDLA "Results" clauses; the combined verdict is the most restrictive one. Every verdict cites the clause and the licence URL; sources retrieved 2026-11-01.

      denkwerk
    • Check whether a model license allows your commercial use: verdict, obligations, user and revenue thresholds, naming rules and EU restrictions from a table of checked license texts.

      Resolves a license id (SPDX, Hugging Face license tag or common name) or looks up a Hugging Face model id and its license tag, then evaluates the stated use (commercial, monthly active users, annual revenue, EU establishment, multimodal model, training other models on outputs, derivative model name) against a table built from the primary license texts retrieved 2026-11-01: Apache-2.0, MIT, BSD-3-Clause, CC BY/BY-SA/BY-NC/BY-NC-SA 4.0, CreativeML OpenRAIL-M, Llama 2, 3, 3.1, 3.2, 3.3 and 4 Community Licenses (incl. the EU multimodal clause of the 3.2 and 4 Acceptable Use Policies), Gemma Terms of Use, Qwen and Qwen Research, DeepSeek License, Mistral Research License, Stability AI Community and NVIDIA Open Model License. Licenses outside the table are reported as unknown.

      denkwerk
    • Check whether an answer covers every required point supplied by the caller: per point covered or missing, best evidence sentence, matched and missing terms or keywords, overall coverage.

      For each required point the answer is searched sentence by sentence (and in windows of two adjacent sentences). keywords: every keyword group must occur (any alternative of a group, case-insensitive, whole words). lexical (default): share of the point's content terms found in the best window (Unicode word segmentation (ICU), NFKC, Snowball stop words removed (de/en), German CISTEM stemmer (Weißweiler & Fraser 2017) or English S-stemmer (Harman 1991); numbers kept as terms with decimal comma normalised); covered at or above lexical_threshold (default 0.6) and, unless disabled, only if every number of the point occurs. embedding: cosine similarity between the point ("query: ") and each answer sentence ("passage: ") with intfloat/multilingual-e5-small (MIT, pinned revision, SHA-256 checked, int8 ONNX as in F03); covered at or above semantic_threshold (default 0.8). both: covered if either method says so. The caller defines what counts as complete; no language model decides. State 2026-11-01.

      denkwerk
    • Check whether an answer is written in the language of the question (or an expected language): detected languages with scores, per-segment languages, share of text in the expected language, script check.

      Detects languages with franc-min 6.2 (MIT; trigram profiles from the Universal Declaration of Human Rights, 82 languages with at least 8 million speakers, ISO 639-3). The question (or expected_language) sets the target; the answer is checked as a whole and in segments (paragraphs, long paragraphs split into sentence groups of at least segment_min_chars characters). Reports the share of answer characters in segments of the expected language, a mixed-language flag (any confident segment in another language), the dominant Unicode script of both texts and language names and ISO 639-1 codes from CLDR 48 (ICU 78, Intl API). candidates restricts detection to a list of languages, which helps for short texts.

      denkwerk
    • Check whether an x402 resource is listed in the Coinbase CDP Bazaar: search plus complete merchant pagination with an honest listed/not listed/unknown verdict.

      Derives payTo from the live 402 challenge if not supplied, first tries the CDP natural-language search filtered by payTo, then paginates the CDP merchant discovery list for that payTo (100 entries per page, the CDP maximum; parallel, up to 400 pages, failed pages are retried within the time budget) and looks for the exact resource URL. "not_listed" is only returned after a complete scan with a stable total; otherwise the verdict is "unknown". Returns the catalog entry with lastUpdated when found.

      denkwerk
    • Check whether evaluation items appear in a training or reference corpus by n-gram overlap, per item and overall.

      Builds the set of word n-grams (default 8, configurable 5–13) of the supplied corpus and reports for every evaluation item the share of its n-grams found in the corpus, the longest matching span and a contaminated flag above the threshold. Mirrors the n-gram overlap method used in published contamination analyses; corpus up to 20 MB of text.

      denkwerk
    • Check whether packages named in generated code actually exist in npm, PyPI or crates.io, to catch hallucinated dependency names (slopsquatting).

      Takes package names (or extracts them from JavaScript require/import, Python import and requirements lines) and queries the public registry APIs of npm, PyPI and crates.io. Reports exists/not found, first release date and latest version; very recently created packages are flagged because attackers register names that models tend to hallucinate. Python import names are not always identical to distribution names; such cases are marked.

      denkwerk
    • Checklist of EU AI Act duties for providers of general-purpose AI models: GPAI status, systemic-risk presumption, open-source exemption, Annex XI/XII items and deadlines, each with its article.

      Rule engine over Regulation (EU) 2024/1689 as amended by Regulation (EU) 2026/1744 (consolidated text of 2026-07-27; the GPAI articles are unchanged): Art. 3(63) and the indicative criterion of the Commission guidelines C(2025) 7719 (approved 18 July 2025), paragraph 17 (training compute above 10^23 FLOP and generation of language, text-to-image or text-to-video), Art. 51(2) presumption above 10^25 FLOP, Art. 52(1) two-week notification, Art. 53(1)(a)–(d) with Annex XI Section 1 and Annex XII items, Art. 53(2) and 54(6) open-source exemption (not for systemic-risk models; Recital 103 and guidelines section 4.2.2 on monetisation), Art. 54 authorised representative for non-EU providers, Art. 55(1)(a)–(d) and Annex XI Section 2, downstream modifiers (guidelines paragraphs 60–61: one third of the original compute, or of 10^25/10^23 FLOP if unknown; Recital 109), and the dates of Art. 113 (2 August 2025), Art. 111(3) (2 August 2027 for models placed before) and Art. 101 fines (from 2 August 2026).

      denkwerk
    • Classify tool and API errors from an agent run into actionable classes (auth, permission, schema, rate limit, timeout, payment required …) with remediation.

      Matches status codes and error messages against ordered rules for payment required (402/x402), authentication, permission, rate limiting, validation/schema, not found, timeout, upstream failure and network errors. Returns the class per error, counts per class and tool, whether a retry makes sense and a remediation hint per class. Rule-based and explainable; unmatched messages stay "unknown".

      denkwerk
    • Collect question-answer pairs that documentation already contains: question headings, Q/A labels, FAQPage JSON-LD, details/summary and definition lists, with the answer text and source location.

      Parses Markdown (marked), HTML (cheerio; pages fetched with robots.txt respected) or plain text into headings and blocks and keeps only questions that are explicitly present: headings ending with a question mark, "How to …" headings (turned into "How do I …?" by a fixed template) and German "Wie …" headings, paragraphs labelled Q:/A:, Frage:/Antwort:, bold questions followed by an answer, schema.org FAQPage markup, <details><summary> and <dt>/<dd> pairs. The answer is the text below the question up to the next heading, cut at a sentence boundary to max_answer_words. Returns pairs with kind, heading path and line, counts per kind and a ready FAQPage JSON-LD object. Nothing is invented: content without an explicit question yields no pair.

      denkwerk
    • Compare how 2 to 6 tokenizers split the same text: token pieces with byte offsets, pairwise boundary agreement and the words that are split most differently.

      The text is NFC-normalized, tokenized by each selected tokenizer and every token is mapped back to its exact UTF-8 bytes (tiktoken byte table; GPT-2 byte mapping for byte-level BPE; Metaspace and byte-fallback for SentencePiece-style vocabularies). Tokens that end inside a multi-byte character are marked partial and shown as hex. Agreement between two tokenizers is the Jaccard index of their internal token boundaries (byte offsets). Words (Unicode word segmentation) are listed with their pieces where the tokenizers disagree. Same tokenizer set as token-count-multi.

      denkwerk
    • Compare old and new model outputs on the same test set with fixed metrics (exact match, SQuAD EM/F1, chrF, JSON validity, refusals): wins, losses, mean change, exact sign test and the worst regressions.

      For each item the old and new output are scored with the selected metrics: exact_match (trimmed string equality), squad_em and token_f1 (official SQuAD v1.1 normalisation: lower case, ASCII punctuation and articles a/an/the removed; best over several references), chrf (chrF2 as in sacreBLEU 2.x: character n-grams 1-6 without whitespace, beta 2, best reference), json_valid (parses after stripping code fences), refusal (rule set of refusal-detect, lower is better). Paired comparison per metric: win/loss/tie with a tolerance, means, mean delta and an exact two-sided sign test (binomial, ties dropped); verdict regression or improvement when p < alpha. Without references, agreement (token F1 and identical share between old and new) and the reference-free metrics are reported. Returns the items with the largest drop on the primary (first) metric.

      denkwerk
    • Compare two versions of an agent configuration (tools and OAuth scopes) and highlight newly granted dangerous capabilities.

      Takes the tool names (with optional descriptions) and permission scopes of an agent before and after a change and reports added and removed tools and scopes, classifies new capabilities by risk (payments, sending messages, deleting or writing data, code execution, credential access, external network) from names, descriptions and scope strings, and returns a risk delta. Useful as a review gate in CI for agent deployments.

      denkwerk
    • Compress a prompt without changing its content: whitespace, JSON minification, invisible characters, duplicate lines and Markdown decoration, with a token and fidelity report.

      Deterministic transformations in two levels. lossless: removes zero-width and BOM characters, turns no-break spaces into spaces, strips trailing whitespace, collapses inner space runs and blank-line runs, minifies JSON code blocks or a pure-JSON prompt; fenced code blocks are otherwise left untouched (indentation matters). light additionally removes HTML comments, ** and __ emphasis markers, horizontal rules after blank lines, table cell padding and exact duplicate lines (15+ characters). Each step reports its token savings with the chosen tokenizer; the quality check compares numbers, URLs, unique words and code blocks before and after.

      denkwerk
    • Condense an OpenAPI 3 document into a token-budgeted guide for agents: per operation the required inputs, auth and scopes, response shape and detected pitfalls (pagination, rate limits, idempotency, async, int64 ids).

      Resolves local $refs and allOf, then describes every operation compactly (method, path, operationId, summary, required and optional parameters with enums, request body fields with required markers, success response shape, documented error codes, effective security with OAuth2 scopes) and applies rule checks: cursor, offset or page pagination (parameter and response field names), list endpoints without pagination, documented 429 and Retry-After or RateLimit headers, Idempotency-Key headers versus non-idempotent POST, 202 asynchronous responses with Location, deprecated operations and parameters, multipart or binary uploads, oneOf/anyOf/discriminator bodies, additionalProperties false, int64 identifiers that exceed JavaScript's safe integer range, required nullable fields, date-time parameters and missing error documentation. The Markdown guide is filled until max_tokens (o200k_base, js-tiktoken) and lists the remaining operations by name.

      denkwerk
    • Convert a USDC or EURC amount, or the stablecoin transfers of a Base transaction, into euro using the ECB reference rate of the payment day.

      Uses the ECB euro foreign exchange reference rate USD per EUR (series EXR.D.USD.EUR.SP00.A) for the payment date, falling back to the last published rate before a weekend or TARGET holiday, and divides USDC amounts by it under the stated assumption USDC = 1 USD; EURC is taken as 1 EUR. For a transaction hash the date comes from the Base block time. Returns rate, rate date and the euro amount rounded to cents.

      denkwerk
    • Convert an MCP tools/list result into an OpenAPI 3.1 document with one POST operation per tool (reverse direction of openapi-to-mcp).

      Each MCP tool becomes POST /tools/{name} with its inputSchema as JSON request body, outputSchema (if present) as 200 response schema, the description as operation description and the tool name as operationId. Useful to document an MCP server for HTTP clients or to feed REST-only tooling. Tool names are kept; path-unsafe characters are percent-encoded.

      denkwerk
    • Convert fine-tuning and chat datasets between OpenAI chat messages, Alpaca, ShareGPT and prompt/completion JSONL, with per-line validation.

      Reads JSONL in any of four common layouts (OpenAI chat "messages", Alpaca instruction/input/output, ShareGPT "conversations" with from/value, prompt/completion), validates roles and empty turns, and writes the target layout line by line. Lines that cannot be represented in the target (for example multi-turn chats into Alpaca) are reported with their line number instead of being changed silently.

      denkwerk
    • Count the tokens of a text for 12 tokenizers at once: OpenAI o200k/cl100k/p50k/r50k plus Qwen, DeepSeek, Mistral Tekken, Falcon, GPT-NeoX, Yi, Granite and GLM.

      Exact counts, not estimates: OpenAI encodings via js-tiktoken, other families via their published tokenizer.json (Hugging Face, pinned revisions, SHA-256 checked, open licenses only: Apache-2.0 or MIT) run with transformers.js. Every Hugging Face tokenizer was checked token by token against the Rust reference implementation on a 29-text corpus. Llama and Gemma tokenizers are excluded for licensing reasons. Special-token strings in the text are counted as each tokenizer treats them by default (tiktoken: plain text; Hugging Face: added tokens). The first call on a server downloads the tokenizer files once (about 56 MB). The result lists all supported tokenizers with license, source and model families (as of 2026-11-01).

      denkwerk
    • Create a private review link for an exact action fingerprint, record approval or rejection once, and retrieve status or receive an ownership-verified signed webhook.

      Creates a SQLite-backed request with separate random approval and read-only status tokens. The reviewer opens the private fragment link, reads the plain-text proposal and SHA-256 fingerprint, explicitly confirms review and records approve/reject. Decisions cannot be replaced. POST approval_id and status_token to the returned status_url for free polling. Optional HTTPS webhook requires an exact origin-hosted ownership proof and a private secret; delivery rechecks ownership, sends HMAC-SHA256(timestamp + "." + raw JSON) in X-Halowerk-Signature with X-Halowerk-Timestamp, and retries up to three times with a stable Idempotency-Key. Tokens are hashed in the coordination database; webhook secrets are AES-256-GCM encrypted with a protected local key. HALOWERK records link possession, never verifies reviewer identity or executes the proposed action.

      denkwerk
    • Cut a document down to a token budget by dropping the lowest-priority sections first and truncating the last one at a sentence boundary; exact count of the result.

      Accepts explicit sections with priorities (or Markdown that is split at headings, with optional priorities by heading text). Required sections are never dropped. Sections are removed in order of ascending priority (later sections first on ties); the last removed section is re-added in shortened form, cut at a sentence boundary (Unicode sentence segmentation), if space remains. The final text is counted again with the chosen tokenizer, so separators and token merges at the joins are included. Any of the 12 tokenizers of token-count-multi can be used.

      denkwerk
    • Daily spending limit for autonomous agents: set a cap per agent, then authorise and record each spend before paying.

      Namespaced budgets per agent and UTC day. "set_limit" defines the daily cap and optional per-transaction cap; "authorize" atomically checks amount against both caps and the day total and records it if allowed (with an optional reference); "status" shows spent, remaining and recent entries. Use it in front of x402 payments so several agents share one budget. Amounts are kept in micro-units to avoid rounding errors.

      denkwerk
    • Decide for each URL an agent wants to open whether it passes a policy: schemes, allow/deny domains, IP literals, private ranges, credentials, ports and IDN homographs.

      Static policy evaluation without resolving or fetching anything: allowed schemes, domain allow and deny lists with subdomain matching, IP-literal and private/reserved address rejection, embedded credentials, non-standard ports, maximum length, forbidden query keys and punycode (IDN) labels that mix scripts. Returns allow/deny per URL with every reason, so an agent runtime can enforce it before a fetch.

      denkwerk
    • Derive a quickstart from a repository: prerequisites, install, configure, build, run and test commands with their source, environment variables and ports, from the README and manifest files.

      Reads the README (Markdown code blocks in shell languages, prompts stripped, multi-line commands joined) and classifies commands into clone, install, configure, build, run and test; then fills missing phases from manifests: package.json (scripts, engines, packageManager), pyproject.toml (TOML subset: project, requires-python, scripts, Poetry and uv), requirements.txt, Makefile targets, Dockerfile (FROM, EXPOSE, CMD), docker-compose ports, Cargo.toml, go.mod and .env.example variables. Every step names its source (README line or manifest field). Files can be supplied directly or fetched from a public GitHub repository (one listing via the GitHub API, at most five raw files). Commands are only collected, never executed.

      denkwerk
    • Detect data-exfiltration links in model output or documents: auto-loading images, high-entropy URL parameters, DNS-style subdomains and request-capture services.

      Extracts markdown links and images, HTML images and bare URLs and flags those that could leak data when rendered or followed: images (they load without a click), high-entropy or base64-like query values, suspicious parameter names (token, key, secret, history), long high-entropy subdomain labels (DNS exfiltration), template placeholders and known request-capture services (webhook.site, ngrok, interact.sh and similar). Heuristic; reasons are listed per URL.

      denkwerk
    • Detect loops in an agent run: identical repeated tool calls, A-B-A-B cycles and stretches without new results.

      Hashes every tool call (tool name plus canonical arguments) and optional result, then reports exact repeats, periodic cycles of length 2 to 5 that repeat at least three times, and stagnation windows where several consecutive calls return results already seen. Returns the positions, the cycle pattern and a stop recommendation for the orchestrator.

      denkwerk
    • Detect refusals, partial refusals and evasive answers in model outputs with disclosed English and German rules; signals with offsets, label per response and refusal rate for batches.

      Rule-based, no model. Every sentence (ICU segmentation) is matched against 18 disclosed rules in English and German: direct refusals (first person + can't/cannot/won't + action verb; German first person + modal + negation + action verb), explicit declines, policy references, capability limitations, referrals to professionals, AI-identity disclaimers, apologetic openings, alternative offers and hedges. refusal: at least one strong signal, no alternative offer and fewer than 40 words in sentences without signals; partial_refusal: strong signal plus an alternative offer or at least 40 such words; evasion: only medium signals (capability limitation, referral) and fewer than 40 such words; compliance_with_caveats: medium signals with at least 40 such words; compliance: no strong or medium signal. The response contains every rule with its description so results can be audited. Accepts one response or a batch of up to 500.

      denkwerk
    • Distributed lease lock with fencing tokens for agent swarms: acquire, renew and release a named lock with a TTL.

      Namespaced leases: "acquire" grants the lock to an owner id if it is free or expired and returns a monotonically increasing fencing token; "renew" extends a lease held by the same owner; "release" frees it; "status" shows holder and expiry. TTL 5 seconds to 1 hour. Fencing tokens let downstream systems reject writes from a stale holder. The namespace is claimed with a secret on first use.

      denkwerk
    • Draft an annotation guideline skeleton from labelled examples: per label the distinguishing terms, examples, and confusable pairs to clarify.

      Takes example texts per label and derives, without a language model, the most distinguishing terms per label (TF-IDF contrast against the other labels), representative examples, cross-label example pairs with high similarity that need a written decision rule, and labels with too few examples. Returns a Markdown guideline skeleton with placeholders for the definitions an expert must write.

      denkwerk
    • Draw a reproducible sample from tabular data with columns that contain personal data detected and dropped or masked first.

      Scans every column of up to 100,000 rows for e-mail addresses, IBANs, phone numbers, IPv4 addresses and Luhn-valid card numbers, plus columns whose names indicate personal data (name, email, phone, address, birth, iban, ip …). Flagged columns are dropped or masked, then a seeded random sample of the requested size is drawn. Returns the sample, the column decisions with match rates and the remaining residual matches (should be 0).

      denkwerk
    • Draw a reproducible, representative evaluation sample from logs: strata from fields and/or text clusters, proportional or equal allocation, SHA-256 keyed selection with a seed, weights per stratum.

      Strata are the combinations of the values of stratify_by fields and, optionally, of a text clustering (TF-IDF over Unicode words without Snowball stop words, smooth idf ln((1+N)/(1+df))+1, L2-normalised; farthest-first initialisation (Gonzalez 1985) seeded by the SHA-256 key, then spherical k-means (Dhillon & Modha 2001) for at most 30 iterations). Allocation: proportional (largest remainder method on n*N_h/N) or equal (n/H, capped at the stratum size, surplus moved to strata with spare records), then at least min_per_stratum per stratum (units taken from the stratum with the largest allocation above its own minimum). Within a stratum the records with the smallest SHA-256(seed + U+001F + id) are taken (bottom-k), so any tool can reproduce the selection and adding records keeps existing choices stable. Optional exact-duplicate removal on a text field. Returns ids, strata with population, allocation, inclusion probability and design weight N_h/n_h.

      denkwerk
    • Estimate the GPU memory needed to serve a model: weights by quantization, KV cache by context and batch, compute buffer and overhead, each with its formula, plus a fit check.

      Disclosed formulas: weights = parameters × bits per weight / 8 (llama.cpp file types use the effective bits measured on Llama-3.1-8B in tools/quantize/README.md, commit ad1b88c; data types FP32/FP16/FP8/INT8/INT4 their width); KV cache = 2 × layers × KV heads × head dimension × context × batch × bytes per element of the cache type (MLA models: layers × (kv_lora_rank + rope dim) × context × batch); compute buffer = ubatch × (vocabulary + 4 × hidden size) × 4 bytes as a llama.cpp-style assumption; plus a fixed overhead you can set. Architecture comes from your input or the Hugging Face config.json and safetensors parameter count. Optional fit check against a GPU from the datasheet table or a VRAM size.

      denkwerk
    • Expand a German search query: OpenThesaurus synonyms per sense, compound splitting with linking elements (Fugen-s, -en, -e plus umlaut), umlaut and ß transliterations, ready Boolean query.

      Synonyms come only from OpenThesaurus (export of 2026-10-31, LGPL-2.1+ or CC BY-SA 4.0, attribution in every answer), grouped by synset so different senses stay apart; colloquial, vulgar and dated entries are excluded unless requested. Compounds are split with own logic: dynamic programming over the OpenThesaurus single-word lexicon (99,460 words) plus optional corpus words, allowing the German linking elements -e-, -s-, -es-, -n-, -en-, -er-, -ens- and the subtractive -e (list per de.wikipedia.org/wiki/Fugenelement, retrieved 2026-11-01), umlaut reversal for -e-/-er- joints and inflected final parts via CISTEM stems. The split with the fewest parts wins; parts with 12 or more letters are split again as fine parts. Words that are themselves in the lexicon are split only from 12 letters on. Transliterations ä/ae, ö/oe, ü/ue, ß/ss are added both ways. The Boolean query ORs each word with its variants, synonyms and the AND of its compound parts.

      denkwerk
    • Extract machine-readable rule candidates from API terms of use: rate limits and quotas, cache and retention durations, prohibitions (resale, scraping, AI training …), duties, governing law, each with its sentence.

      Splits the terms (text, Markdown, HTML or a public URL with robots.txt respected) into sections and sentences and applies documented English and German pattern lists: request limits ("1,000 requests per day", "500 Anfragen pro Minute"), durations ("for up to 24 hours", "höchstens 7 Tage"), modality (must not/may not/prohibited/untersagt → prohibited; must/shall/müssen → required; may/dürfen → permitted), topics (resale and sublicensing, scraping, reverse engineering, AI/ML training, competing products, benchmarking, circumvention of limits, credential sharing, caching and storage, attribution, commercial use, personal data, unlawful use) and exception wording (unless, except, without prior written consent, es sei denn). Governing law and jurisdiction clauses are captured. Normative sentences that match no topic are listed separately for human review. Every rule cites its sentence, section and line; nothing is interpreted beyond the patterns.

      denkwerk
    • Extractive summary of a PDF or paged text: the most central sentences, verbatim and in document order, each with its page number, optionally focused on a query.

      Extracts the text layer of every PDF page with pdfjs-dist (or takes pages as text, or text split by form feeds), removes lines repeated on most pages (headers, footers), joins hyphenated line breaks and splits sentences with Intl.Segmenter plus abbreviation rules. Sentences of 5 to 80 words are ranked with LexRank (Erkan and Radev 2004: TF-IDF cosine graph, damping 0.85); an optional query boosts sentences containing its terms, and near-duplicates (cosine above 0.6) of already chosen sentences are skipped. The result lists the chosen sentences unchanged with page, position and score, so every statement can be cited. Purely extractive: nothing is paraphrased or generated.

      denkwerk
    • Find and remove near-duplicate documents with MinHash and LSH banding, verified by exact Jaccard similarity; returns kept ids, removed ids with their original and clusters.

      Each document becomes a set of shingles (word n-grams after Unicode word segmentation and lower casing, or character n-grams). MinHash signatures use one 32-bit FNV-1a hash per shingle and num_perm deterministic MurmurHash3-finalizer permutations; locality-sensitive hashing with b bands of r rows (the largest r for which a pair exactly at the threshold is missed with at most 5 % probability) proposes candidate pairs, which are then verified with the exact Jaccard similarity of the shingle sets. Pairs at or above the threshold are clustered (union-find); the first or the longest document of each cluster is kept. Method after Broder (1997) and Leskovec, Rajaraman, Ullman, Mining of Massive Datasets, chapter 3. The result reports the probability that LSH misses a pair exactly at the threshold.

      denkwerk
    • Find probably mislabelled text examples: items whose nearest neighbours (TF-IDF cosine) mostly carry a different label.

      Builds TF-IDF vectors for up to 5000 labelled texts and, for each item, looks at its k nearest neighbours by cosine similarity. Items where at least the given share of neighbours agree on another label are reported with the suggested label, the agreement and the most similar neighbours, sorted by confidence. A lexical heuristic for review queues, not a ground-truth decision.

      denkwerk
    • Find tools in one toolset that a model could confuse: pairwise similarity of names, descriptions and parameter sets with clusters.

      Compares every pair of tools by cosine similarity of description words, Jaccard similarity of name tokens and of parameter names. Pairs above the threshold are reported with the shared terms and a suggested distinction; overlapping pairs are grouped into clusters. Deterministic bag-of-words method, no embeddings.

      denkwerk
    • Generate a Hugging Face style dataset card (YAML metadata plus Markdown sections) from dataset facts and a row sample.

      Builds README.md content for a dataset: YAML front matter with license, languages, task categories, size category computed from the row count and pretty name; sections for summary, structure (fields with inferred types and an example row), sources, intended use, limitations and license. Fields not supplied are marked as "[More information needed]" instead of being invented.

      denkwerk
    • Generate a deterministic retrieval evaluation set from your passages: inverse-cloze sentence queries and keyword queries, each with its target passage and BM25 difficulty.

      Without a language model: for every passage the most distinctive sentence (highest mean IDF over the corpus, at least min_sentence_words words) becomes an inverse-cloze query and is removed from its target passage before evaluation (Lee, Chang and Toutanova 2019, inverse cloze task); in addition the top TF-IDF terms of the passage form a keyword query. Each pair is checked against a BM25 index over all passages (corpus statistics from the full passages; the target is scored without its query sentence) and labelled easy (rank 1), medium (2 to 5) or hard (lower or not found). Same input, same output; no randomness.

      denkwerk
    • Generate an A2A Agent Card (JSON) from basic metadata and either a skill list or an OpenAPI document, validated for required fields.

      Builds an Agent2Agent protocol Agent Card with protocolVersion, name, description, url, version, capabilities, default input/output modes and skills. Skills come from the supplied list or are derived from OpenAPI operations (operationId, summary, tags). Missing required fields are reported as errors instead of being invented. Output is ready to serve at /.well-known/agent-card.json.

      denkwerk
    • Generate an llms.txt file (llmstxt.org format) from a sitemap: title, summary and link sections grouped by path.

      Parses a sitemap (urlset; a sitemap index is reported with its child sitemaps) supplied inline or fetched from a public URL, groups pages by their first path segment, derives readable link names from the slugs and writes llms.txt Markdown with an H1 title, a blockquote summary and one H2 section per group. The optional pages limit keeps the file short; dropped pages are counted.

      denkwerk
    • Generate and validate x402 payment identifiers (payment-identifier extension) and decide idempotency outcomes for repeated submissions.

      Implements the x402 payment-identifier extension: generates identifiers (prefix plus random UUID v4 without dashes), validates given ids against the 16–128 character rule with alphanumerics, hyphens and underscores, returns the PaymentRequired advertisement and the PaymentPayload echo snippets, and decides the server reaction for pairs of submissions (new id, same id with same payload returns the cached response, same id with a different payload returns 409, missing id when required returns 400).

      denkwerk
    • Generate x402 v2 payment metadata for MCP tools: PaymentRequired per tool, bazaar extension of type mcp, and the exact _meta keys for payment and settlement.

      For each MCP tool and price, builds the PaymentRequired object as defined by the x402 v2 MCP transport (tool result with isError true, structuredContent and the same JSON in content[0].text), the accepts entry in atomic units for USDC on Base, and the bazaar discovery extension of input type "mcp" with toolName, description, inputSchema and transport. The bazaar info is validated against its schema. Includes the client key _meta["x402/payment"] and server key _meta["x402/payment-response"].

      denkwerk
    • Hybrid search over supplied documents: BM25 plus dense vectors from a local open-license embedding model, fused by Reciprocal Rank Fusion or weighted scores.

      Ranks up to 100 supplied documents twice: lexically with BM25 (same implementation and defaults as bm25-search) and semantically by cosine similarity of embeddings computed locally (multilingual: intfloat/multilingual-e5-small, MIT, with the required "query: "/"passage: " prefixes, truncation at 512 tokens; english: sentence-transformers/all-MiniLM-L6-v2, Apache-2.0, truncation at 256 word pieces; mean pooling and L2 normalization, int8 ONNX exports from the model repositories, pinned and checksummed). Fusion rrf sums 1/(k + rank) over both lists (Cormack, Clarke and Büttcher 2009, k = 60); weighted combines min-max-normalized scores with weight alpha for the vector part. Documents are embedded one by one so scores do not depend on the batch; per call at most 6,000 model tokens (multilingual) or 16,000 (english). The first call on a server downloads the model once.

      denkwerk
    • Idempotency keys for agents: record the result of an operation once and get it back for repeated attempts; conflicting payloads are rejected.

      Namespaced key/value store for idempotent retries. "begin" claims a key with a payload hash (new, in_progress or completed with the stored result; a different payload under the same key returns a conflict), "complete" stores the result (up to 64 KB) and "get" reads the state. Keys expire after the chosen TTL (max 7 days). The namespace is claimed with a secret on first use and only its HMAC is stored.

      denkwerk
    • Image input tokens per provider and model from the pixel size: OpenAI patch and tile rules, Claude 28-px visual tokens with tier resizing, Gemini media_resolution.

      Implements the published formulas: OpenAI patch-based models (32-px patches, model and detail-specific maximum dimension and patch budget, model multiplier, 30,000-patch rejection) and tile-based models (2048 fit, 768 shortest side, 512-px tiles, base plus tile tokens); Anthropic visual tokens ceil(w/28) x ceil(h/28) after the documented resize to the standard (1568 px, 1568 tokens) or high-resolution tier (2576 px, 4784 tokens, Claude 4.7 and later) with half-to-even rounding; Gemini 3 and 4 media_resolution token counts and the Gemini 2.x 258-token/768-px tile rule (approximate). Sources: OpenAI images-vision guide, Claude vision guide, Gemini media-resolution and token pages, all retrieved 2026-11-01.

      denkwerk
    • Keyword search over supplied documents with Okapi BM25 (k1 and b adjustable), optional German CISTEM stemming, matched terms, IDF table and snippets.

      Builds an in-memory BM25 index over up to 5000 supplied documents (title and text) and ranks them for the query. Formula per Robertson & Zaragoza (2009): sum over distinct query terms of idf(t) * tf * (k1+1) / (tf + k1 * (1 - b + b * |d| / avgdl)), with idf = ln(1 + (N - n + 0.5) / (n + 0.5)) and the Lucene defaults k1 = 1.2, b = 0.75 (Apache Lucene 10.3 BM25Similarity). Terms come from Unicode word segmentation, NFKC and lower case; stemming german applies the CISTEM stemmer (Weißweiler & Fraser 2017, MIT reference implementation). Returns scores, matched terms, the IDF of every query term and a snippet around the densest match.

      denkwerk
    • Lint an x402 PaymentRequired (live URL or pasted object) for Bazaar cataloging: v2 fields, bazaar extension validity, example body, service metadata and header size.

      Fetches the live 402 challenge or takes a pasted PaymentRequired object and checks it against the x402 v2 specification and the bazaar extension: x402Version, resource url/description/mimeType, accepts entries (amount, asset, payTo, maxTimeoutSeconds, EIP-712 domain), presence of extensions.bazaar, info validated against its JSON Schema with Ajv (draft 2020-12) as facilitators must do, example body against the declared body schema, serviceName/tags/iconUrl soft-drop rules and PAYMENT-REQUIRED header size. Returns findings with severity and a listing_ready verdict.

      denkwerk
    • Lint tool definitions for agent usability: vague or missing descriptions, undocumented parameters, generic names, unexplained enums, duplicate names.

      Runs deterministic rules over tool definitions in any common format: description missing, too short (<40 characters) or too long (>1024), vague verbs without an object, parameters without description, generic parameter names such as data/input/value, enums without explanation, negated boolean names, inconsistent name style and duplicate names. Returns findings per tool and a score from 0 to 100.

      denkwerk
    • Look up benchmark scores of a language model from Epoch AI's own evaluations (GPQA Diamond, MATH Level 5, FrontierMath, SWE-bench Verified and more) with stderr, date and licence.

      Searches the Epoch AI Benchmarking Hub snapshot of 2026-10-31 (downloaded 2026-11-01 from https://epoch.ai/data/benchmark_data.zip, licence CC BY 4.0) for model versions matching your name (case and punctuation ignored, version dots kept). Only the benchmarks Epoch AI runs itself are included; externally sourced leaderboards in the same archive keep their original licences and are left out. Each result carries mean score, best score, standard error, evaluation start time, model release date, organisation, the public log viewer link and the random baseline. Attribution text for CC BY is returned.

      denkwerk
    • Measure how diverse a prompt or evaluation set is: length spread, languages, exact and near duplicates, distinct-n and dominant terms.

      For up to 20,000 prompts computes length statistics, language shares (franc-min, trigram based), exact duplicates after normalisation, near-duplicate pairs by word 3-gram Jaccard ≥ 0.8 (sampled for large sets), distinct-1 and distinct-2 ratios and the terms that dominate the set. Useful before running evaluations or fine-tuning on a synthetic prompt set.

      denkwerk
    • Measure label distribution of a classification dataset: counts, shares, imbalance ratio, normalised entropy and inverse-frequency class weights.

      Counts labels (single-label or multi-label lists), computes shares, the ratio between the most and least frequent class, normalised Shannon entropy (1 = perfectly balanced), classes below a minimum count and balanced class weights n_samples / (n_classes × count) as used by common training libraries.

      denkwerk
    • Measure the token surcharge of languages from parallel texts: tokens per language and tokenizer, ratio and percent versus a reference language, optional monthly volume and cost.

      Give the same content in 2 to 12 languages. Each sample is language-identified with franc-min (ISO 639-3) unless declared, tokenized with the selected tokenizers and compared with the reference sample (default: the English sample, else the first): ratio, surcharge in percent, tokens per word and characters per token. With a monthly reference volume and price the projected tokens and cost per language are added. Samples whose length deviates strongly from the reference are flagged because they may not be translations of each other.

      denkwerk
    • Normalize rate-limit and retry information from OpenAI, Anthropic, Groq, GitHub, IETF RateLimit fields, Retry-After and Google RetryInfo into one structure with a wait time.

      Parses response headers (and optionally a JSON error body) into limits with remaining quota, reset in seconds and absolute reset time, plus one recommended wait. Supported formats with sources (retrieved 2026-11-01): Retry-After per RFC 9110 (seconds or HTTP-date); OpenAI x-ratelimit-*-requests/-tokens/-project-tokens with Go-style durations; Groq (same names, requests per day, tokens per minute); Anthropic anthropic-ratelimit-* and anthropic-priority-* with RFC 3339 resets; GitHub x-ratelimit-limit/remaining/used/reset/resource; IETF draft-ietf-httpapi-ratelimit-headers-11 RateLimit-Policy and RateLimit structured fields; google.rpc.RetryInfo retryDelay in error bodies.

      denkwerk
    • Pack the best passages into a token budget with Maximal Marginal Relevance: relevance from your scores or BM25, redundancy from TF-IDF cosine, exact token count, citation labels.

      Selects passages greedily by Maximal Marginal Relevance (Carbonell and Goldstein 1998): lambda * relevance - (1 - lambda) * maximum TF-IDF cosine similarity to the passages already chosen; passages that no longer fit the budget are skipped. Relevance is the supplied score divided by the highest score, or the BM25 score against the query divided by the highest one. Each passage is rendered with a template such as "[{id}] {text}" and the final context is counted exactly with the chosen OpenAI encoding. Order options: selection order, source order, or edges (most relevant at the start and end, after Liu et al. 2023, Lost in the Middle).

      denkwerk
    • Pick the llama.cpp quantization (GGUF file type) with the best published quality that fits your GPU memory, optionally with CPU offload, and list all candidates with sizes and perplexity cost.

      For every llama.cpp file type, weights = parameters × effective bits per weight (measured on Llama-3.1-8B, tools/quantize/README.md, commit ad1b88c) plus KV cache and overhead (same formulas as vram-estimate) are compared with the memory budget. Quality comes from the perplexity increase that llama.cpp publishes per type in tools/quantize/quantize.cpp (Llama-3-8B, commit 732707d): tiers near_lossless ≤ 0.03, high ≤ 0.2, balanced ≤ 0.7, low above (tier limits are this service's convention). The recommendation is the lowest-perplexity type of the accepted tiers that fits entirely in GPU memory; if none fits, the best one that fits with CPU offload; with min_quality "any", types without published perplexity (IQ quants) are ranked by bits per weight. Types that need an importance matrix (src/llama-quant.cpp) are flagged.

      denkwerk
    • Profile a table (rows as JSON objects): types, missing values, distinct counts, numeric statistics, top values and IQR outliers per column.

      For up to 200,000 rows infers each column type (number, integer, boolean, date, string, mixed), counts missing and distinct values, computes min, max, mean, standard deviation and quartiles for numeric columns, lists the most frequent values and flags outliers outside 1.5 × IQR, plus constant and all-unique (likely identifier) columns.

      denkwerk
    • RAG evaluation without an LLM judge: context precision, context recall, faithfulness, answer relevance and correctness (lexical or embeddings), plus IR metrics (P@k, R@k, MRR, AP, nDCG) when relevant ids are known.

      All metrics are defined in the response. With relevant_ids: precision@k and recall@k over the first k contexts, MRR, average precision and nDCG@k with binary relevance and log2 discount. Without relevant_ids, a context counts as relevant when it supports the reference (or the question if no reference) at or above the threshold; context precision = mean of precision@i over relevant positions (rank-weighted, as in RAGAS but without an LLM judge). Context recall: share of reference sentences supported by the contexts. Faithfulness: share of answer sentences supported by at least one context (unsupported sentences are listed; numbers must occur in the supporting context). Answer relevance: share of question content terms in the answer (lexical) or cosine question-answer (embedding). Answer correctness: SQuAD token F1 against the reference. lexical support = share of a sentence's content terms present (Unicode word segmentation (ICU), NFKC, Snowball stop words removed (de/en), German CISTEM stemmer (Weißweiler & Fraser 2017) or English S-stemmer (Harman 1991); numbers kept as terms with decimal comma normalised); embedding support = cosine with intfloat/multilingual-e5-small (MIT, pinned, int8 ONNX as in F03), best context sentence. method both requires both.

      denkwerk
    • Read a mail thread (mbox, raw message with quoted history or structured messages) and return its state: messages in order, participants, open questions, commitments with due dates, who waits on whom.

      Parses RFC 5322 messages including mbox separators, folded headers, RFC 2047 encoded words, MIME multipart (text/plain preferred, HTML converted with quote levels), quoted-printable and base64 bodies. Quoted history is split off at ">" quote blocks, "On … wrote:" / "Am … schrieb …:" attributions and Outlook "Original Message"/"Ursprüngliche Nachricht" header blocks, recursively, so a single forwarded mail yields its earlier messages; copies of messages already present are dropped. Greetings, closings and signatures are removed, sentences are split, questions are sentences ending with "?" and are open while no later message from another participant exists; commitments are first-person promise phrases (English and German pattern lists) with due dates resolved by chrono-node relative to the message date.

      denkwerk
    • Read only the header of a GGUF or safetensors file via HTTP range requests: architecture, quantization mix, parameter count, context length, attention layout and licence fields.

      Fetches the first megabytes of a public model file with HTTP Range requests (growing until the header is complete, at most 32 MiB; the weights are never downloaded) or takes the leading bytes as base64. GGUF v2/v3: all metadata keys (arrays summarised), tensor infos, ggml tensor types with block sizes from llama.cpp (MIT, commit a91eab6), file type name, parameter count, tensor bytes, effective bits per weight, context length, layers, heads, KV heads, head dimension, vocabulary size, general.license fields and the f16 KV-cache bytes per token. Safetensors: header JSON, dtype mix, parameter count, tensor bytes and __metadata__. For Hugging Face files the repository licence tag is added.

      denkwerk
    • Reorder prompt segments for provider prompt caching: stable content first, volatile last, breakpoint positions, minimum-length check and a cost factor.

      Takes the prompt as segments with a change frequency (never, daily, per_session, per_request), detects volatile content such as timestamps, dates, UUIDs and epoch values inside supposedly stable segments, reorders segments so the longest stable prefix comes first (Anthropic: tools, system, messages order is kept), places up to four breakpoints at stability boundaries, checks the documented minimum cacheable length and estimates the input cost factor for N requests sharing the prefix. Rules from the official Anthropic, OpenAI and Gemini caching documentation as of 2026-11-01. Token counts use an OpenAI encoding; they are exact only for OpenAI models that tiktoken maps to that encoding and estimates otherwise (flag tokens_are_estimates).

      denkwerk
    • Replay logged tool-call arguments against a new schema version and report which calls would now fail and why.

      Validates up to 500 recorded argument objects against a new input schema (JSON Schema, draft 2020-12 features via Ajv, formats included). Reports per call whether it passes, the validation errors with JSON pointers, fields that the new schema no longer knows and required fields that the old calls never sent. Useful before shipping a tool schema change.

      denkwerk
    • Report the USDC or EURC outflows of an agent wallet on Base for the last 1–72 hours, grouped by recipient and UTC day.

      Queries Transfer events from the wallet on Base mainnet via public RPC in 10,000-block windows and sums them by recipient and by UTC day. Timestamps are derived from block numbers using the fixed 2-second Base block time, anchored at the latest block (or at to_block for a fixed historical window). Covers token transfers only (no ETH gas). Useful for checking what an autonomous agent actually paid for x402 calls.

      denkwerk
    • Rerank candidate passages for a query with a cross-encoder: multilingual model for 14 languages incl. German (default) or an English MS MARCO model; scores, ranks and probabilities.

      Scores every (query, passage) pair with a cross-encoder run locally through transformers.js/ONNX Runtime and sorts by the model logit; relevance is the logistic sigmoid of the logit. multilingual: cross-encoder/mmarco-mMiniLMv2-L12-H384-v1 (Apache-2.0, trained on mMARCO: en, ar, zh, nl, fr, de, hi, id, it, ja, pt, ru, es, vi). english: cross-encoder/ms-marco-MiniLM-L6-v2 (Apache-2.0, MS MARCO, English only). Both are the int8 ONNX exports published in the model repositories (pinned revisions, SHA-256 checked); pairs are scored one by one so a score does not depend on the other passages; pairs longer than max_length (default and maximum 512 tokens) are truncated and flagged. Per call at most 8,000 model tokens (multilingual) or 20,000 (english) are accepted. The first call on a server downloads the model once (about 136 MB multilingual, 24 MB English).

      denkwerk
    • Reveal text smuggled past humans: decode Unicode tag-character messages, locate zero-width and bidi control characters and mixed-script words.

      Decodes hidden ASCII messages written with Unicode tag characters (U+E0000–E007F, used to smuggle prompts past reviewers), lists zero-width and bidirectional control characters with positions (Trojan Source, CVE-2021-42574) and flags words that mix Latin with Cyrillic or Greek letters. Returns the cleaned text alongside the findings so an agent can continue safely.

      denkwerk
    • Rough tokens per second for a model on a GPU: memory-bound decode, compute-bound prefill, time to first token and batch throughput, from datasheet bandwidth and TFLOPS with stated efficiencies.

      Roofline-style estimate with all assumptions in the result: each decode step reads the active weights once (parameters × bits per weight / 8) plus the KV cache of every sequence (same KV formula as vram-estimate), so t_memory = bytes / (bandwidth × memory_efficiency); it needs 2 × active parameters × batch FLOP, so t_compute = FLOP / (dense FP16 TFLOPS × compute_efficiency); the slower one bounds the step. Prefill tokens/s = TFLOPS × efficiency / (2 × active parameters), time to first token = prompt tokens / prefill rate. GPU figures come from vendor datasheets and whitepapers retrieved 2026-11-01 (dense values, sparsity figures halved) or from your own numbers; multi-GPU assumes ideal tensor-parallel scaling.

      denkwerk
    • Runnable example calls (curl, Python requests, JavaScript fetch) from an OpenAPI 3 document or from curl/HTTP examples found in Markdown or HTML docs, with placeholders listed.

      OpenAPI 3.0/3.1: for every operation builds a request from the first server (variables resolved) or base_url, path, query and header parameters, the security scheme of the operation (API key in header/query/cookie, bearer, basic, OAuth2 as environment-variable placeholders) and the request body from documented examples, defaults or enums, otherwise from the schema with type and format placeholders; JSON bodies are validated against their schema (Ajv) and every generated, undocumented value is listed. Docs mode: code blocks of Markdown or HTML are scanned for curl commands (shell quoting, line continuations, -X/-H/-d/--json/-u/-F/-G and more) and raw HTTP request blocks; each becomes a normalised request with placeholders such as $API_KEY or <token> listed. Snippets for curl, Python and JavaScript are generated from the normalised request.

      denkwerk
    • Sanitize a tool output before it goes back to the model: strip markdown images, untrusted links, HTML, invisible characters and flag instruction-like lines.

      Takes text returned by a tool (web page, email, file, API) and applies a configurable policy: removes markdown and HTML images (a common exfiltration channel), turns links to domains outside the allow list into plain text, strips HTML tags and scripts, removes zero-width, bidi and Unicode tag characters, truncates to a maximum length and marks lines that match instruction-override or AI-addressing patterns with a [flagged] prefix. Returns the sanitized text and every change.

      denkwerk
    • Scan MCP or function tool definitions for hidden instructions aimed at the model (tool poisoning), invisible characters and encoded payloads.

      Searches names, descriptions, parameter descriptions, titles, enum values and defaults for instruction overrides, requests to conceal actions from the user, references to sensitive files and secrets, cross-tool directives, exfiltration wording, hidden tag blocks, invisible Unicode (zero-width, bidi, tag characters) and long base64 blobs. Pattern-based and explainable; a clean result is not a security guarantee.

      denkwerk
    • Scan a web page for hidden instructions aimed at AI agents: invisible text, comments, alt/title/meta attributes and instruction patterns.

      Fetches the page (robots.txt respected) or takes supplied HTML and inspects every place an agent may read but a human does not see: elements hidden by inline CSS (display:none, visibility:hidden, zero font size, zero opacity, off-screen), HTML comments, alt/title/aria-label attributes, meta tags, noscript and template blocks, plus invisible Unicode and decoded Unicode tag-character messages. Each text is matched against instruction-override, AI-addressing, concealment, exfiltration and tool-directive patterns. Returns findings with location, excerpt and an overall risk level.

      denkwerk
    • Scan generated shell, Python, JavaScript or SQL for dangerous operations before an agent runs it: destructive deletes, pipe-to-shell, disabled TLS, reverse shells and more.

      Line-based rule set across languages: recursive deletes of root or home, pipe-to-shell installers, chmod 777, disk formatting and dd to devices, fork bombs, reverse shells, eval/exec of dynamic input, shell=True and child_process.exec, disabled TLS verification, private keys and AWS-style keys in code, SQL DROP/TRUNCATE and DELETE/UPDATE without WHERE, GRANT ALL and crypto-miner keywords. Returns findings with line number, rule and severity and an overall verdict.

      denkwerk
    • Score English texts for toxicity, severe toxicity, obscenity, identity attack, insult, threat and sexually explicit content with the open Detoxify "unbiased" model (Apache-2.0), run locally.

      Runs unitary/unbiased-toxic-roberta (Detoxify "unbiased", RoBERTa-base, Apache-2.0, trained on Civil Comments from the Jigsaw Unintended Bias challenge; dataset card CC0-1.0) through transformers.js/ONNX Runtime, using the int8 ONNX export onnx-community/unbiased-toxic-roberta-ONNX (Apache-2.0; pinned revision d1d71b6, SHA-256 checked). Scores are sigmoid outputs per label (multi-label), texts are scored one by one and truncated at 512 tokens (flagged). Only English is supported: every text is checked with franc-min and skipped with a reason (instead of being scored) when English ranks more than 10 % below the best language; texts under 20 characters are not checked. Per call at most 32 texts and 8,000 model tokens. The first call on a server downloads about 129 MB once.

      denkwerk
    • Send the same bounded JSON GET to two or three explicitly authorized HTTPS endpoints and collect ordered results with per-target timeouts.

      Parallel JSON GET collection from two or three origin-authorized endpoints. Every origin must publish /.well-known/halowerk-fanout.json with exact target URLs and SHA-256 of your private proof preimage. All proofs pass before target requests start. Returns ordered JSON results or explicit errors, timings and raw-response hashes. No arbitrary relay, credentials, custom headers, query, redirects, retries or payments.

      denkwerk
    • Shared token-bucket rate limiter for several agents calling the same API: take tokens and get allowed/denied with retry-after.

      Namespaced token buckets with capacity and refill rate defined by the caller. "take" removes n tokens if available and otherwise returns the exact retry-after time; "peek" shows the current level; "reset" refills the bucket. Bucket state is computed lazily from timestamps, so no background job is needed. The namespace is claimed with a secret on first use.

      denkwerk
    • Simplify a JSON Schema for language-model tool use: inline local $refs, merge allOf objects, collapse single-branch unions and strip meta keywords.

      Inlines local $ref targets from $defs/definitions (recursion is reported, not expanded), merges allOf lists of object schemas, collapses anyOf/oneOf with a single branch, removes $schema/$id/$comment/readOnly/writeOnly/deprecated and lists properties that still lack a description. Returns the simplified schema, every change with its JSON pointer and size/depth before and after.

      denkwerk
    • Split Markdown, HTML or plain text into retrieval chunks that respect headings, sentences and a token limit, with sentence overlap and heading-path metadata.

      Parses the document into blocks (Markdown via marked, HTML via a block-level walker that drops scripts and styles, plain text by blank lines), keeps a heading path for every block and never mixes sections in one chunk. Blocks are packed up to max_tokens (OpenAI encoding via js-tiktoken); oversized blocks are split at sentence boundaries (Unicode segmentation plus CLDR abbreviation list, e.g. "z. B.", "Dr."), oversized sentences at word boundaries. Overlap repeats whole trailing sentences of the previous chunk of the same section up to overlap_tokens. Every chunk carries its text, exact token count, heading path, block kinds and character offsets into the LF-normalized source (HTML: into the extracted text).

      denkwerk
    • Split a dataset into train/validation/test reproducibly with a seed, stratified by label and optionally grouped so related rows never cross splits.

      Assigns each row to train, validation or test using the given fractions and a seeded generator, so the same input and seed always give the same split. With a label field the split is stratified per label; with a group field all rows of one group (for example one customer or one document) land in the same split to prevent leakage. Returns row indices per split and label counts per split.

      denkwerk
    • Static security review of a system prompt: embedded secrets, missing instruction hierarchy, unfenced user input, over-permissive phrases and missing tool limits.

      Reviews a system prompt without running a model, using rules derived from common prompt-injection guidance: credentials or keys embedded in the prompt (critical), no statement that instructions inside user content or tool results must not be followed, placeholders for untrusted input without delimiters, phrases like "always comply" or "never refuse", no guidance about revealing the prompt, no limits for tool use and payments. Returns findings with severity, a score and concrete fixes. It does not prove robustness against live attacks.

      denkwerk
    • Test an OpenAI-compatible endpoint (vLLM, Ollama, LiteLLM, proxies): models list, chat, streaming, tools, JSON modes, error format and usage fields, with a verdict.

      Sends up to nine short live probes to the base_url you give, as the OpenAI SDK would (GET /models; POST /chat/completions plain, streaming with stream_options.include_usage, forced tool call, response_format json_object and json_schema; a malformed body, an unknown model and a request without key) and checks each answer against the OpenAI Chat Completions format: object types, ids, choices, roles, finish_reason, usage arithmetic, SSE chunks and the [DONE] marker, tool_calls with JSON-string arguments, schema-valid JSON content and {"error": {...}} error bodies. The optional API key is sent only to base_url (redirects are refused), never logged, stored or returned; server echoes of it are redacted. Probes are billed by your provider (at most 64 output tokens each). Rules follow the public OpenAI API reference (Chat Completions, streaming, function calling, structured outputs, error format).

      denkwerk
    • Translate tool/function definitions between OpenAI, OpenAI Responses, Anthropic, Gemini and MCP formats with a warning for every lossy change.

      Accepts tool definitions in any of the five common formats (mixed lists allowed) and emits them in the requested target format. Gemini output is reduced to the documented Schema subset with upper-case types; every dropped keyword, reduced union and renamed tool is reported as a warning instead of being changed silently. Deterministic, no model involved, nothing stored.

      denkwerk
    • Turn RPM/TPM/ITPM/OTPM/daily limits and a workload into a sustainable request rate, concurrency (Little's law), batch duration, token-bucket settings and a capped backoff plan.

      For each limit the request rate it allows is computed (RPM directly, TPM from input plus counted output tokens, ITPM and OTPM separately, RPD and TPD as daily caps), a safety margin is applied and the binding constraint is reported. Concurrency follows Little's law (rate x latency). Provider rules from the official docs (retrieved 2026-11-01): OpenAI counts the larger of max_tokens and the expected output toward the token limit; Anthropic counts only uncached input toward ITPM on most models and only actual output toward OTPM. The retry plan is exponential backoff with full jitter (delay drawn uniformly from 0 to the cap); the plan lists the caps, no random numbers.

      denkwerk
    • Turn a sitemap (URL, domain or inline XML, also gzip and sitemap indexes) into a searchable index: sections, languages and hreflang groups, terms per URL and BM25 search with filters.

      Reads urlset or sitemapindex XML (sitemaps.org protocol, with the image, video, news and xhtml:link hreflang extensions), inline or fetched (robots.txt respected; for a domain the Sitemap lines of robots.txt, else /sitemap.xml; gzip supported; at most three child sitemaps of an index, two when a domain is given, so no more than five requests per call). Each URL gets terms from its decoded path segments (split on separators and camelCase, extensions and stop words removed) plus news, image and video titles, a language from its own hreflang, news language or path prefix (/de/, /en_GB/), and a section from the first path segment after the language. Returns statistics, sections with the latest lastmod, languages, hreflang groups, the most frequent terms, compact entries and, for a query, BM25-ranked results (k1 1.2, b 0.75) filtered by section, language or lastmod.

      denkwerk
    • Turn a specification into a checkable requirement list: every sentence with an RFC 2119/8174 keyword (MUST, SHOULD, MAY …) or German MUSS/SOLLTE/KANN, with strength, section, line, subject and condition.

      Splits the document (text incl. RFC-style numbered headings, Markdown, HTML or a public URL) into sections and sentences and finds the BCP 14 keywords of RFC 2119 as clarified by RFC 8174 (MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, NOT RECOMMENDED, MAY, OPTIONAL) or the German modal verbs used for requirements in the BSI IT-Grundschutz-Kompendium (MUSS, DARF NICHT, DARF NUR, SOLLTE, SOLLTE NICHT, KANN). If the BCP 14 boilerplate is present or capitalised keywords are used, only capitalised forms count (RFC 8174); otherwise lowercase forms are reported with low confidence. The boilerplate sentence and quoted keywords are skipped. Each item carries the RFC level, strength, section, line, the words before the keyword as subject and a condition flag; a Markdown checklist is included.

      denkwerk
    • Turn an x402 payment transaction on Base into a payment receipt PDF and structured JSON for bookkeeping (payer, payee, amount, block, time).

      Reads the transaction receipt and block from Base mainnet, extracts USDC and EURC Transfer events, and renders an A4 payment receipt PDF (English or German) with transaction hash, block, UTC time, sender, recipient, amount and optional party names and reference. The receipt documents an on-chain payment; it is explicitly not a tax invoice, so no ZUGFeRD data is embedded. The SHA-256 of the PDF is returned for archiving.

      denkwerk
    • Turn tables in HTML, Markdown or plain text (pipe, grid, CSV/TSV, aligned columns) into clean JSON records with typed values, units and normalised keys.

      HTML tables are expanded cell by cell including rowspan and colspan, header rows come from <thead> or all-<th> rows and multi-row headers are joined ("2025 / Revenue"). Text input is scanned for Markdown pipe tables (marked), grid tables (+---+), delimiter tables (tab, semicolon, comma via csv-parse) and whitespace-aligned columns. Values are typed per column only when every non-empty cell fits: integer, number (decimal comma or dot decided per table from unambiguous values, German page language as tie-breaker), percent, currency with ISO code, ISO date (also DD.MM.YYYY) and boolean (yes/no/ja/nein/true/false/✓). Keys are snake_case with umlaut transliteration and de-duplication. Pages are fetched with robots.txt respected.

      denkwerk
    • Turn your own x402 request log into a payment funnel per endpoint: challenges, paid attempts, verify and settle failures, invalid input and successes.

      Takes up to 20,000 request events of your own resource server (status code, path, whether a payment header was present, error code, payer) and computes per endpoint the funnel from 402 challenge to paid attempt to settled success, the conversion rates, the top failure codes and unique payers. Pure computation on the supplied events; nothing is fetched or stored.

      denkwerk
    • Validate an agent plan as a dependency graph: missing inputs, cycles, unreachable steps and which steps can run in parallel.

      Each step declares the steps it needs and the artifacts it produces and consumes. The service checks that every referenced step exists, every consumed artifact is produced by an earlier dependency or supplied as initial input, detects cycles, lists steps that nothing depends on (dead ends besides declared goals) and groups the steps into topological levels that can run in parallel.

      denkwerk
    • Validate fine-tuning JSONL before upload: OpenAI chat and preference format, Anthropic Messages style, Hugging Face messages and ShareGPT, with line-numbered errors, duplicates and token counts.

      Parses every line and checks the documented structure: OpenAI chat format with the checks of the OpenAI cookbook "Chat fine-tuning data prep" (data_type, missing_messages_list, message_missing_key, message_unrecognized_key, unrecognized_role, missing_content, example_missing_assistant_message) plus weight 0/1 on assistant messages, tool_calls with JSON-string arguments and tool messages bound to a tool_call_id; OpenAI preference (DPO) records; Anthropic Messages-style records (top-level system, user/assistant alternation, first user, last assistant); Hugging Face/TRL "messages" and ShareGPT "conversations" (human/gpt). Finds exact duplicates and identical prompts with different answers, counts tokens with js-tiktoken per the cookbook formula (3 per message plus 3) and estimates OpenAI billing tokens and default epochs with the cookbook heuristic.

      denkwerk