New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Provenance Grade

by CALLE-AI in CALLE-AI/awesome-phone-call-agents

Attach an advisory knowledge grade — verified / asserted / assumed — to fields a CALL-E phone agent extracts, using heuristic signals in the transcript turns the API returns.

MITAuto-check passed

Install Provenance Grade

skills CLI
$ npx skills add CALLE-AI/awesome-phone-call-agents --skill provenance-grade -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install CALLE-AI/awesome-phone-call-agents provenance-grade --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/CALLE-AI/awesome-phone-call-agents.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/provenance-grade .claude/skills/provenance-grade && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
provenance-grade
GitHub stars
107
Token cost
~2.4k tokens
SKILL.md length
968 words
Files
59 (incl. scripts, references, assets)
Skills in repo
101
Repo updated
First seen
Licence
MIT

At a glance

Attach an advisory knowledge grade — verified / asserted / assumed — to fields a CALL-E phone agent extracts, using heuristic signals in the transcript turns the API returns.

  • SKILL.md covers Why this is not a duplicate of…, The grades, Two halves and How the grade is computed, plus 3 more sections
  • Calls npm

What it does

Provenance Grade is an agent skill from CALLE-AI/awesome-phone-call-agents. Attach an advisory knowledge grade — verified / asserted / assumed — to fields a CALL-E phone agent extracts, using heuristic signals in the transcript turns the API returns.

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 60 other files, including scripts, reference files and assets (for example `assets/fixtures/01-verified-weekday-stock-hold.json`, `assets/fixtures/02-verified-price-invoice.json` and `assets/fixtures/03-asserted-direct-eta.json`).

The repository describes itself as: Portable phone-call Agent Skills, apps, examples, adapters, and scheduler recipes for AI agents. The licence is MIT.

Example prompts

  • “/provenance-grade”

What it can do on your machine

Read from SKILL.md and the folder at commit 38d4118. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/, which the agent can run.

    Shell commands in SKILL.md call:

    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use npm, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Provenance Grade loads about 2.4k tokens when it runs, and up to ~6.5k if it reads all its reference files. Until then it costs about 48 tokens; SKILL.md has 968 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~48
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from CALLE-AI/awesome-phone-call-agents at commit 38d4118, republished under its MIT licence (© CALLE-AI). 968 words, ~2,442 tokens.

Download SKILL.mdSave it as .claude/skills/provenance-grade/SKILL.md (or your agent's skills folder). This skill also uses 58 other files; get the full folder from GitHub.
name
provenance-grade
description
Attach an advisory knowledge grade — verified / asserted / assumed — to fields a CALL-E phone agent extracts, using heuristic signals in the transcript turns the API returns.

provenance-grade

Every phone agent extracts what was said and throws away how the speaker knew it.

Speech carries the speaker's epistemic state; text hides it. Structured extraction throws that signal away. This skill puts it back: it reads recipients[i].attempts[j].transcript_turns from a completed CALL-E call and attaches a knowledge grade to every extracted field, with the exact transcript span that supports it.

This skill never places calls: it lints a task before a host dispatches it and grades a transcript after a call has completed. It contains no dialing code, no phone numbers, and no network calls of any kind.

Two calls can both answer "Tuesday." In one, the person said "hold on, let me check", went quiet for eleven seconds, and came back with "Tuesday — we're holding eleven units at the Bhiwandi warehouse." In the other, they said "should be Tuesday" half a second after the question. Same extracted value. Completely different knowledge. The first is verified; the second is assumed — and if your workflow auto-commits on the second one, the extraction was correct and the answer was still wrong.

Why this is not a duplicate of anything in this repo

CALL-E already returns completion_confidence — but by its own documentation that is confidence that the task reached a clear end state, explicitly not confidence in the quality of the business answer. That is a documented, self-acknowledged gap, and this skill fills exactly it.

Against the other skills here: call-summarizer summarises after the fact. voice-preflight checks audio before the call. linecanary monitors line health. Nothing grades the epistemic basis of a spoken claim.

The grades

GradeMeaning
verifiedThe heuristic detects a lookup pause or explicit check language, plus an unrequested corroborating specific, plus read-back compliance where requested. This label is not proof that a lookup occurred or that the answer is true.
assertedAnswered directly and cleanly, but nothing established where the value came from.
assumedHedged, deferred, misaligned with the question, or a bare round number. The call did not establish this value.
unstatedThe field never appeared in the transcript (voicemail, IVR, unanswered question). Never a grade — there is nothing to grade.

Consumer rule: grades are advisory inputs to the host's own validation, not independent authorization to act. Keep a human in the loop for asserted, and never auto-act on assumed or unstated. The high-stakes prohibitions in references/safety.md apply to every grade, including verified.

Fail-closed: the default is assumed. asserted must be earned, verified must be earned twice. Absence of signal never upgrades a field. This is the same discipline this repo rewards everywhere else, applied one level up.

Two halves

Pre-call — scripts/lint-task.ts. Amends the caller's task text and result_schema so the signals are actually elicitable: forces a read-back of critical values, rewrites "do you know?" into "can you check?", asks for one corroborating specific, and gives the agent permission to wait while the person looks something up. You improve the signal you will later measure.

ts
import { lintTask } from './scripts/lint-task.ts';

const { task, result_schema, amendments } = lintTask({
  task: 'Call the supplier. Do you know the unit price and delivery date?',
  result_schema: mySchema,
  critical_fields: ['unit_price', 'delivery_day'],
});
// -> task now asks "can you check", requests a read-back, asks for one specific

Post-call — scripts/grade.ts. Reads the transcript turns and emits a grade plus the supporting span per field.

ts
import { gradeCall } from './scripts/grade.ts';

const provenance = gradeCall({
  callId: call.id,
  recipientId: recipient.id, // an ORGANISATION id, never a person
  turns: attempt.transcript_turns, // { speaker, text, offset_seconds }
  fields: [
    {
      field: 'delivery_day',
      value: extracted.delivery_day, // from CALL-E's structured output
      expects: 'weekday',            // duration | weekday | date | price | count | text
      questionTurn: 2,               // where the bot asked
      answerTurns: [4],              // where the person answered ([] if never answered)
      readbackRequested: true,
      critical: true,
    },
  ],
});
// provenance.fields[0] ->
// { field: 'delivery_day', value: 'Tuesday', grade: 'verified',
//   signals: ['A:gap=12.6s', 'B:let me check', "C:stock_count 'eleven units'", "C:place 'Bhiwandi'"],
//   span: 'It ships Tuesday. We are holding eleven units at the Bhiwandi warehouse for you.',
//   turnOffset: 26, unstable: false, gapSeconds: 12.6 }

Output contract (scripts/types.ts):

ts
type Grade = 'verified' | 'asserted' | 'assumed' | 'unstated';

interface FieldProvenance {
  field: string;              // "eta_days"
  value: unknown;             // 5
  grade: Grade;
  signals: string[];          // ["B:let me check", "C:place 'Bhiwandi'"]
  span: string;               // exact transcript text supporting the value
  turnOffset: number | null;
  unstable: boolean;          // value was stated then revised (signal I)
  gapSeconds: number | null;
}

interface CallProvenance {
  callId: string;
  recipientId: string;        // organisation-level, never a person
  fields: FieldProvenance[];
  weakestGrade: Grade;        // the call is only as good as its worst critical field
  gradedAt: string;
}
Show full SKILL.md (461 more words)Show less

How the grade is computed

Nine signals, described with examples in references/signals.md: retrieval gap (A), explicit check language (B), corroborating specific (C), hedging lexicon (D), deferral (E), read-back compliance (F), round-number shape (G), answer alignment (H), self-correction (I). They feed a fixed rule table:

if field not present in transcript      -> 'unstated'   (never a grade)
if E or H                               -> 'assumed'
if D present                            -> 'assumed'
if (B or A) and C and (F if requested)  -> 'verified'   (never when unstable)
if answered directly, no D/E/H          -> 'asserted'   (unless G with no C)
otherwise                               -> 'assumed'

Deterministic vs model-assisted — honestly. Signals A, B, D, E, F, G and I are regex and arithmetic. Signals C and H need semantics; in this build they run on a deterministic entity heuristic, and each exposes a provider interface (CorroborationProvider, AlignmentProvider) where a model can be plugged in — a model is constrained to returning spans, never a grade. The grade itself is always computed by the rule table above, never by a model's opinion. That is what makes it testable: 125 unit tests and a confusion matrix over 24 labelled fixtures, zero calls, zero network.

truth \ pred   verified  asserted  assumed  unstated
verified          4         0         0        0
asserted          0         6         0        0
assumed           0         1         9        0
unstated          0         0         0        4      -> 23/24 (95.8%)

The one miss is deliberate and shipped as a fixture: a code-switched answer whose hedge is the Hindi "shayad", which the English lexicon cannot see (assets/fixtures/23-codeswitch-hindi-hedge-missed.json). A named limitation beats a silent one. Reproduce with npm run eval; run tests with npm test.

Ethics boundary

This skill grades behaviour, not people.

  • No emotion detection, no stress or deception scoring, no voice biometrics. (Also impossible here by construction: CALL-E exposes no audio to grade — only transcript text and integer offsets.)
  • Hosts should associate grades with an organisation, not an individual. This pure grader does not enforce identifier contents or anonymize input: values, transcript spans and caller-supplied IDs may identify people. The caller must minimize inputs and redact display/export copies before sharing them.
  • A low grade means the call did not establish this, never this person lied.
  • Transcript spans are retained only as the minimum quote supporting one field.

Full statement: references/ethics.md.

Limitations

Stated, not hidden — the full list with reasoning is references/limitations.md. Headlines: offset_seconds marks turn start at integer resolution, so the latency signal is weak and weighted accordingly; ASR errors corrupt hedge detection; the lexicon is English-centric and swappable (scripts/lexicon/en.json), with the Hindi file (scripts/lexicon/hi.json) shipped unvalidated; directness is cultural — a terse answer is not necessarily a guess; and the grades are not yet validated against outcomes.

Roadmap (stated, not built)

The grade is a prediction. The validation is: record the grade, wait for the promised event, record whether it held, and measure grade-vs-outcome accuracy per organisation. Over enough calls this produces a calibration curve and a per-supplier reliability score — a supplier whose asserted Tuesdays actually arrive on Tuesday earns trust; one whose verified claims fail flags a broken lookup process. None of that is built and none of it is tested. It is named here because naming the unvalidated claim is what separates a measure from a demo.

CALL-E tells you the call finished. This tells you whether to believe it.

© CALLE-AI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 58 other files (scripts, references, assets) in skills/provenance-grade of CALLE-AI/awesome-phone-call-agents.

  • SKILL.md
  • .gitignore
  • assets/fixtures/01-verified-weekday-stock-hold.json
  • assets/fixtures/02-verified-price-invoice.json
  • assets/fixtures/03-asserted-direct-eta.json
  • assets/fixtures/04-asserted-direct-price.json
  • assets/fixtures/05-assumed-hedged-weekday.json
  • assets/fixtures/06-assumed-hedged-eta.json
  • assets/fixtures/07-assumed-deferral-warranty.json
  • assets/fixtures/08-assumed-deferral-colleague.json
  • assets/fixtures/09-assumed-misaligned-price.json
  • assets/fixtures/10-assumed-misaligned-eta.json
  • assets/fixtures/11-unstable-selfcorrect-eta.json
  • assets/fixtures/12-unstable-selfcorrect-price.json
  • assets/fixtures/13-verified-readback-complied-price.json
  • assets/fixtures/14-verified-readback-complied-date.json
  • assets/fixtures/15-asserted-readback-refused-price.json
  • assets/fixtures/16-asserted-readback-refused-date.json
  • assets/fixtures/17-unstated-voicemail-eta.json
  • … and 40 more

Open the folder on GitHubat commit 38d4118

Compare with similar skills

Provenance Grade next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Provenance Grade compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Provenance Grade this skillCALLE-AI/awesome-phone-call-agents107—~2.4kAutomated safety check: PassMIT
Gh Attachsickn33/agentic-awesome-skills47k1 repos~1.6kAutomated safety check: PassMIT
Gh Attachgithub/awesome-copilot40k—~529Automated safety check: PassMIT
Esign Field Placementaffaan-m/ECC277k—~2.6kAutomated safety check: PassMIT
Fieldsparcadei/Continuous-Claude-v33.9k1 repos~693Automated safety check: NotesMIT
Deal With Security Advisorypaperclipai/paperclip100k—~2kAutomated safety check: PassMIT

Similar skills

  • Gh Attach

    sickn33/agentic-awesome-skills

    Upload and download GitHub user-attachments (screenshots, PDFs, zips, videos) from the terminal; use when asked to attach or embed a file in a PR, issue, or comment, or download an attachment URL.

    47k GitHub starsUsed in 1 repo~1.6k tokens
    Documents & OfficeAuto-check passed

  • Gh Attach

    github/awesome-copilot

    Official

    Uploads a local file (screenshot, image, PDF, zip, video) to GitHub user-attachments, downloads GitHub user-attachments, and embeds local files in a PR, issue, or comment.

    40k GitHub stars~529 tokensUpdated 2 days ago
    Documents & OfficeAuto-check passed

  • Esign Field Placement

    affaan-m/ECC

    Deterministic method for placing signature, date, and text fields in a web e-signature composer through a browser automation session, using a fixed signature page, numeric Location panel coordinates…

    277k GitHub stars~2.6k tokensUpdated today
    Productivity & AutomationAuto-check passed

  • Fields

    parcadei/Continuous-Claude-v3

    Problem-solving strategies for fields in abstract algebra. An agent skill from parcadei/Continuous-Claude-v3.

    3.9k GitHub starsUsed in 1 repo~693 tokens
    Research & ScienceAuto-check: notes

  • Deal With Security Advisory

    paperclipai/paperclip

    Handle confidential GitHub Security Advisory response for Paperclip.

    100k GitHub stars~2k tokensUpdated today
    SecurityAuto-check passed

  • Provenance

    anbeime/skill

    收集系统全链路操作日志，生成可追溯的执行证据链与向量索引，是多智能体系统可观测性与安全审计的底座. An agent skill from anbeime/skill.

    7.8k GitHub stars~301 tokensUpdated 2 days ago
    Auto-check passed

More from CALLE-AI/awesome-phone-call-agents

All 101 skills in this repo

  • Accessible Outing Verifier

    CALLE-AI/awesome-phone-call-agents

    Demonstrates advisory accessibility-planning checks with offline fixtures and a proposed bounded CALL-E workflow; use for exploring unknown or qualified venue claims without making calls.

    107 GitHub stars~1.4k tokensUpdated yesterday
    Auto-check passed

  • Ground Truth Gate

    CALLE-AI/awesome-phone-call-agents

    A skill your agent uses when an agent holds some evidence for a physical-world claim but the evidence is broader, narrower, or older than the exact question asked, and it must first decide whether a…

    107 GitHub stars~3.3k tokensUpdated yesterday
    Auto-check passed

  • Is It Accessible

    CALLE-AI/awesome-phone-call-agents

    Call a venue and ask the accessibility questions that matter to one specific person — step-free entry, hearing loop, guide dogs, quiet hours, changing places — then return a per-need verdict backed…

    107 GitHub stars~4.3k tokensUpdated yesterday
    Auto-check passed

  • Landmark Navigation Assist

    CALLE-AI/awesome-phone-call-agents

    Turns a pre-written, building-level location config into a CALL-E outbound phone-call task that guides a delivery driver through the last few hundred metres to a specific building using landmarks…

    107 GitHub stars~1.6k tokensUpdated yesterday
    Auto-check passed

  • Research Gap Call Verifier

    CALLE-AI/awesome-phone-call-agents

    Turn cited business research into a bounded, approval-gated phone-call plan that asks only unresolved factual questions, then reconcile CALL-E-compatible results without treating voicemail, refusal…

    107 GitHub stars~1.7k tokensUpdated yesterday
    Auto-check passed

  • Structured Outcome Followup Call

    CALLE-AI/awesome-phone-call-agents

    Place a goal-driven CALL-E call that collects specific structured answers, score those answers against a deterministic rubric you supply, and conditionally trigger a follow-up action — all runnable…

    107 GitHub stars~1.4k tokensUpdated yesterday
    Auto-check passed

Questions about Provenance Grade

What does Provenance Grade do?

Attach an advisory knowledge grade — verified / asserted / assumed — to fields a CALL-E phone agent extracts, using heuristic signals in the transcript turns the API returns. Provenance Grade is an agent skill from CALLE-AI/awesome-phone-call-agents. Attach an advisory knowledge grade — verified / asserted / assumed — to fields a CALL-E phone agent extracts, using heuristic signals in the transcript turns the API returns.

How do I install Provenance Grade in Claude Code?

Run `npx skills add CALLE-AI/awesome-phone-call-agents --skill provenance-grade -a claude-code`. Or copy the skill folder (skills/provenance-grade in CALLE-AI/awesome-phone-call-agents) into .claude/skills/provenance-grade in your project. Claude Code loads it when a task matches its description.

How do I install Provenance Grade in Codex?

Run `npx skills add CALLE-AI/awesome-phone-call-agents --skill provenance-grade -a codex`. Or copy the skill folder (skills/provenance-grade in CALLE-AI/awesome-phone-call-agents) into .agents/skills/provenance-grade in your project. Codex loads it when a task matches its description.

Can I use Provenance Grade in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add CALLE-AI/awesome-phone-call-agents --skill provenance-grade -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/provenance-grade, .gemini/skills/provenance-grade, .github/skills/provenance-grade and .opencode/skills/provenance-grade in your project.

What does Provenance Grade need to run?

Going by SKILL.md and its folder, Provenance Grade needs the command-line tools its instructions call (npm).

Does Provenance Grade access the network?

SKILL.md contains no URLs. Its commands use npm, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Provenance Grade safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Provenance Grade use?

Provenance Grade is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Provenance Grade use?

About 2.4k tokens (SKILL.md is roughly 9.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4k tokens, read only when the agent opens those files.

What are the alternatives to Provenance Grade?

Skills that share tags, products or a category with Provenance Grade: Gh Attach (sickn33/agentic-awesome-skills, 47k stars), Gh Attach (github/awesome-copilot, 40k stars), Esign Field Placement (affaan-m/ECC, 277k stars) and Fields (parcadei/Continuous-Claude-v3, 3.9k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Provenance Grade?

CALLE-AI (a GitHub organization) maintains it in CALLE-AI/awesome-phone-call-agents, which has 107 GitHub stars. The repository holds 101 skills in this directory. The repository was last updated on October 10, 2026.

Source: CALLE-AI/awesome-phone-call-agents on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.