Loading skill
Install any skill in seconds. Free to start, no credit card required.
Get Started Free →Double-blind bibliographic cross-check: one agent extracts each cited entry verbatim from the local .bib, a second independently re-fetches the same paper's record from the web while blind to the .bib, and a third extractor emits a mechanical field-by-field delta to catch dropped/re-ordered authors, wrong years, wrong venues, and bad DOIs/arXiv ids. The main agent (never a shard) assigns the MATCH/MINOR/MISMATCH verdict per reference, and exports a side-by-side spreadsheet.
SkillScore91/100
Test results 91
3/3 safety checks passed
32%91%of test cases passed +59 pts
Passed 20 of 22 test cases with the skill, and 7 of 22 without it.
13 fixed7 passed either way2 still failing0 broke
One test taskWhere should the runtime resolve the Step 3.5 verification helper cx_verify.py if running from a repository checkout?
Adds every file the skill has, pinned so you can update it. No account needed.
pip install "decimalai>=0.15"
decimalai skills add wanshuiyin-citation-crosscheck
claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"The same install from Python, for a notebook or a setup script.
pip install "decimalai>=0.15"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
print("Added. Start Claude Code with the command below.")claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"Type these in a Claude Code session. No account or API key. It writes the skill and any files it bundles, and asks first when its safety rating isn't Passed.
/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai/decimalai:install wanshuiyin-citation-crosscheckThe plugin needs python3 and curl on your machine.
No Python or account. Claude Code picks it up in its next session.
curl -fsSL --create-dirs -o .claude/skills/wanshuiyin-citation-crosscheck/SKILL.md https://app.decimal.ai/s/wanshuiyin-citation-crosscheck/SKILL.md.claude/skills/wanshuiyin-citation-crosscheck/SKILL.mdThis gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[claude-agent-sdk]"
decimalai skills add wanshuiyin-citation-crosscheckimport asyncio
from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
async def main():
question = "Hello!"
async with support.run(question) as run: # one user message, one run
async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
print(message)
# In a notebook or async code: await main()
asyncio.run(main())Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[claude-agent-sdk]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
import asyncio
from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
async def main():
question = "Hello!"
async with support.run(question) as run: # one user message, one run
async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
print(message)
# In a notebook or async code: await main()
asyncio.run(main())Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdimport asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
options = ClaudeAgentOptions(system_prompt=f"You are a helpful agent.\n\n{skill}", max_turns=6)
async def main():
async for message in query(prompt="Hello!", options=options):
print(message)
# In a notebook or async code: await main()
asyncio.run(main())This gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai-agents]"
decimalai skills add wanshuiyin-citation-crosscheckfrom agents import Agent, Runner
from decimalai.openai_agents import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
name=support.name,
instructions=support.instructions, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai-agents]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
from agents import Agent, Runner
from decimalai.openai_agents import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
name=support.name,
instructions=support.instructions, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from agents import Agent, Runner
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
agent = Agent(name="support", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")This gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai]"
decimalai skills add wanshuiyin-citation-crosscheckimport json
from openai import OpenAI
from decimalai.openai import agent_config
client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
# run.system is your prompt, then the skill list.
messages = [{"role": "system", "content": run.system}, run.message]
while True:
reply = client.chat.completions.create(
model="gpt-5.4-mini",
messages=messages,
tools=[*TOOLS, *run.tools], # your tools, then load_skill
).choices[0].message
messages.append(reply)
if not reply.tool_calls:
break
for call in reply.tool_calls:
# load_skill is answered by the run; your own tools by FUNCTIONS.
function = FUNCTIONS.get(call.function.name)
messages.append(run.tool_result(call) or {
"role": "tool", "tool_call_id": call.id,
"content": function(**json.loads(call.function.arguments)) if function
else f"There is no tool named {call.function.name!r}.",
})
print(reply.content)
# The Responses API takes run.response_tools instead of run.tools.The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
import json
from openai import OpenAI
from decimalai.openai import agent_config
client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
# run.system is your prompt, then the skill list.
messages = [{"role": "system", "content": run.system}, run.message]
while True:
reply = client.chat.completions.create(
model="gpt-5.4-mini",
messages=messages,
tools=[*TOOLS, *run.tools], # your tools, then load_skill
).choices[0].message
messages.append(reply)
if not reply.tool_calls:
break
for call in reply.tool_calls:
# load_skill is answered by the run; your own tools by FUNCTIONS.
function = FUNCTIONS.get(call.function.name)
messages.append(run.tool_result(call) or {
"role": "tool", "tool_call_id": call.id,
"content": function(**json.loads(call.function.arguments)) if function
else f"There is no tool named {call.function.name!r}.",
})
print(reply.content)
# The Responses API takes run.response_tools instead of run.tools.No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from openai import OpenAI
client = OpenAI()
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
reply = client.chat.completions.create(
model="gpt-5.4-mini",
messages=[
{"role": "system", "content": f"You are a helpful agent.\n\n{skill}"},
{"role": "user", "content": "Hello!"},
],
).choices[0].messageThis gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[anthropic]"
decimalai skills add wanshuiyin-citation-crosscheckimport anthropic
from decimalai.anthropic import agent_config
client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
question = "Hello!"
with support.run(question) as run: # one user message, one run
answer = client.beta.messages.tool_runner(
model="claude-haiku-5-5",
max_tokens=4096,
system=run.system, # your prompt, then the skill list
tools=[*run.tools], # your tools, then load_skill
messages=[{"role": "user", "content": question}],
).until_done()The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[anthropic]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
import anthropic
from decimalai.anthropic import agent_config
client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
question = "Hello!"
with support.run(question) as run: # one user message, one run
answer = client.beta.messages.tool_runner(
model="claude-haiku-5-5",
max_tokens=4096,
system=run.system, # your prompt, then the skill list
tools=[*run.tools], # your tools, then load_skill
messages=[{"role": "user", "content": question}],
).until_done()No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
import anthropic
client = anthropic.Anthropic()
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
reply = client.messages.create(
model="claude-haiku-5-5",
max_tokens=4096,
system=f"You are a helpful agent.\n\n{skill}",
messages=[{"role": "user", "content": "Hello!"}],
)This gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[google-genai]"
decimalai skills add wanshuiyin-citation-crosscheckfrom google import genai
from google.genai import types
from decimalai.google_genai import agent_config
client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
config = types.GenerateContentConfig(
system_instruction=run.system, # your prompt, then the skill list
tools=[*TOOLS, *run.tool_params], # your functions, then load_skill
)
contents = [{"role": "user", "parts": [{"text": run.message}]}]
while True:
response = client.models.generate_content(
model="gemini-3.5-flash", contents=contents, config=config,
)
if not response.function_calls:
break
contents.append(response.candidates[0].content)
parts = []
for call in response.function_calls:
# load_skill is answered by the run; your own functions by FUNCTIONS.
# A loop of your own rather than automatic function calling, which
# raises KeyError when the model asks for a function you did not pass.
function = FUNCTIONS.get(call.name)
parts.append(run.tool_result(call) or {"function_response": {
"name": call.name, "id": call.id,
"response": {"result": function(**(call.args or {})) if function
else f"There is no function named {call.name!r}."},
}})
contents.append({"role": "user", "parts": parts})
print(response.text)The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[google-genai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
from google import genai
from google.genai import types
from decimalai.google_genai import agent_config
client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
config = types.GenerateContentConfig(
system_instruction=run.system, # your prompt, then the skill list
tools=[*TOOLS, *run.tool_params], # your functions, then load_skill
)
contents = [{"role": "user", "parts": [{"text": run.message}]}]
while True:
response = client.models.generate_content(
model="gemini-3.5-flash", contents=contents, config=config,
)
if not response.function_calls:
break
contents.append(response.candidates[0].content)
parts = []
for call in response.function_calls:
# load_skill is answered by the run; your own functions by FUNCTIONS.
# A loop of your own rather than automatic function calling, which
# raises KeyError when the model asks for a function you did not pass.
function = FUNCTIONS.get(call.name)
parts.append(run.tool_result(call) or {"function_response": {
"name": call.name, "id": call.id,
"response": {"result": function(**(call.args or {})) if function
else f"There is no function named {call.name!r}."},
}})
contents.append({"role": "user", "parts": parts})
print(response.text)No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from google import genai
from google.genai import types
client = genai.Client()
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
response = client.models.generate_content(
model="gemini-3.5-flash",
contents="Hello!",
config=types.GenerateContentConfig(system_instruction=f"You are a helpful agent.\n\n{skill}"),
)This gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[langchain]" langchain-openai
decimalai skills add wanshuiyin-citation-crosscheckfrom langchain.agents import create_agent
from decimalai.langchain import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = create_agent(
"openai:gpt-5.4-mini",
tools=[], # your tools; the middleware adds load_skill
middleware=[support.middleware], # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[langchain]" langchain-openaifrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
from langchain.agents import create_agent
from decimalai.langchain import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = create_agent(
"openai:gpt-5.4-mini",
tools=[], # your tools; the middleware adds load_skill
middleware=[support.middleware], # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from langchain.agents import create_agent
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
agent = create_agent("openai:gpt-5.4-mini", tools=[], system_prompt=f"You are a helpful agent.\n\n{skill}")
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})This gets SKILL.md only. The skill's 1 other file is not included.
CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add wanshuiyin-citation-crosscheckimport decimalai.crewai
from crewai import Agent, Crew, Task
agent = Agent(
role="Support", goal="Help the customer", backstory="A support agent.",
llm=llm, # your own CrewAI LLM
skills=decimalai.crewai.skills(), # the installed folder
tools=decimalai.crewai.skill_tools(), # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()The same install from Python, for a notebook or a setup script. CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" "crewai>=1.15.27"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
import decimalai.crewai
from crewai import Agent, Crew, Task
agent = Agent(
role="Support", goal="Help the customer", backstory="A support agent.",
llm=llm, # your own CrewAI LLM
skills=decimalai.crewai.skills(), # the installed folder
tools=decimalai.crewai.skill_tools(), # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()No DecimalAI package. CrewAI's own loader reads the folder, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from crewai import Agent, Crew, Task
agent = Agent(
role="Support", goal="Help the customer", backstory="A support agent.",
llm=llm, # your own CrewAI LLM
skills=[Path(".agents/skills")],
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()This gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[adk]"
decimalai skills add wanshuiyin-citation-crosscheckfrom decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = LlmAgent(
name="support", # ADK needs a Python identifier
model="gemini-3.5-flash",
instruction=support.instruction, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[adk]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = LlmAgent(
name="support", # ADK needs a Python identifier
model="gemini-3.5-flash",
instruction=support.instruction, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from google.adk.agents import LlmAgent
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
agent = LlmAgent(
name="support",
model="gemini-3.5-flash",
instruction=lambda context: f"You are a helpful agent.\n\n{skill}",
)This gets SKILL.md only. The skill's 1 other file is not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[pydantic-ai]"
decimalai skills add wanshuiyin-citation-crosscheckfrom pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
"openai:gpt-4o-mini",
name=support.name,
tools=[], # your tools; the capability adds load_skill
capabilities=[support], # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[pydantic-ai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
"openai:gpt-4o-mini",
name=support.name,
tools=[], # your tools; the capability adds load_skill
capabilities=[support], # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from pydantic_ai import Agent
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
agent = Agent("openai:gpt-4o-mini", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")This gets SKILL.md only. The skill's 1 other file is not included.
Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" deepagents
decimalai skills add wanshuiyin-citation-crosscheckimport decimalai.deepagents
from deepagents import create_deep_agent
agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).
The same install from Python, for a notebook or a setup script. Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" deepagentsfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
import decimalai.deepagents
from deepagents import create_deep_agent
agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from deepagents import create_deep_agent
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
agent = create_deep_agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})This gets SKILL.md only. The skill's 1 other file is not included.
Its own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" agent-framework
decimalai skills add wanshuiyin-citation-crosscheckimport asyncio
from agent_framework import Agent
from decimalai.agent_framework import skills
agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))It caches skills by default, so restart the process after decimalai skills update.
The same install from Python, for a notebook or a setup script. Its own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" agent-frameworkfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
import asyncio
from agent_framework import Agent
from decimalai.agent_framework import skills
agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))It caches skills by default, so restart the process after decimalai skills update.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdimport asyncio
from pathlib import Path
from agent_framework import Agent
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
agent = Agent(client=client, instructions=f"You are a helpful agent.\n\n{skill}")
asyncio.run(agent.run("Hello!"))This gets SKILL.md only. The skill's 1 other file is not included.
Strands' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" strands-agents
decimalai skills add wanshuiyin-citation-crosscheckfrom decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell
agent = Agent(
model=model, # always pass one: the default is Amazon Bedrock
system_prompt="You are a helpful agent.",
tools=[file_editor, shell],
plugins=[skills()],
)
agent("Hello!")Strands loads an agent's skills once, so build the agent again after decimalai skills update.
The same install from Python, for a notebook or a setup script. Strands' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" strands-agentsfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("wanshuiyin-citation-crosscheck")
if result.exit_code:
raise SystemExit(result.problems)
from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell
agent = Agent(
model=model, # always pass one: the default is Amazon Bedrock
system_prompt="You are a helpful agent.",
tools=[file_editor, shell],
plugins=[skills()],
)
agent("Hello!")Strands loads an agent's skills once, so build the agent again after decimalai skills update.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdfrom pathlib import Path
from strands import Agent
skill = Path(".agents/skills/wanshuiyin-citation-crosscheck/SKILL.md").read_text()
agent = Agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent("Hello!")This gets SKILL.md only. The skill's 1 other file is not included.
Adds every file the skill has, pinned so you can update it. Cursor, Copilot, Cline and Warp read this folder by themselves.
pip install "decimalai>=0.15"
decimalai skills add wanshuiyin-citation-crosscheckNo Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.
curl -fsSL --create-dirs -o .agents/skills/wanshuiyin-citation-crosscheck/SKILL.md https://app.decimal.ai/s/wanshuiyin-citation-crosscheck/SKILL.md.agents/skills/wanshuiyin-citation-crosscheck/SKILL.mdThis gets SKILL.md only. The skill's 1 other file is not included.
Give its text to your model as instructions. No account or package needed.
This gets SKILL.md only. The skill's 1 other file is not included.
Raw files: /s/wanshuiyin-citation-crosscheck/SKILL.md · /s/wanshuiyin-citation-crosscheck.json
Fetch the file and give its text to your model as instructions. No account or package needed.
curl -fsSL https://app.decimal.ai/s/wanshuiyin-citation-crosscheck/SKILL.mdcurl -fsSL https://app.decimal.ai/s/wanshuiyin-citation-crosscheck.jsonThis gets SKILL.md only. The skill's 1 other file is not included.
You don't need a DecimalAI account.
Saved prompts and skills, pinned versions, and traces of this skill in your runs. DecimalAI does not run your agent.
Claude Code reads files from your project, so DecimalAI config does not apply there.
On Claude Agent SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On OpenAI Agents: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On OpenAI SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Anthropic: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Gemini API: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On LangChain: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On CrewAI: set DECIMAL_API_KEY and add decimalai.init(crewai=True) to record runs and skill use. The skill version stays in your repo.
On Google ADK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Pydantic AI: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Deep Agents: set DECIMAL_API_KEY and add decimalai.init(langchain=True) to record runs and skill use. The skill version stays in your repo.
On Microsoft Agent Framework: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.
On Strands: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.
Editors read files from your project, so DecimalAI config does not apply there.
Anywhere else: record a use with decimalai.log_skill_activation() inside a trace.
Codex mirror adaptation (normative). This skill has no cross-model jury by design — it is an evidence instrument, not an acquittal step (see the acceptance-gate note in Step 2, and pair it with
citation-auditfor the cross-model verdict). A and B are read-only extraction shards and C emits a mechanical per-field delta, so every verdict is assigned by the main agent from that delta plus its own primary-source fetch — not by any shard and not by a reviewer model.Blindness is NOT automatically identical across hosts — it is conditional on isolation, and the gate enforces that. The whole cross-check rests on B never seeing the
.bib. On the mainline, theAgenttool gives B a fresh context. On a Codex host the frontmatter grants no delegation tool (noAgent, nospawn_agent— seeallowed-tools), so:
- If the host can dispatch B in a genuinely isolated context that does not inherit the main agent's history (which has already read the
.bibin Step 1) — passing B only the title+first-author list — B may setblind:trueand the run certifies normally.- Otherwise (B would run in the main context, or "fresh sequential context" cannot be guaranteed to drop the parent's
.bibview), B MUST setblind:false. The Step-3.5 gate then downgrades everyMATCH/MINORtoESCALATE: the run still flags discrepancies for the main agent's Step-4 webcheck, but it certifies nothing. It is a labelled heuristic, not a double-blind certification.So the mirror never claims blindness it cannot deliver: it either has real isolation and attests it, or it declares
blind:falseand drops to flag-only. Do not add aspawn_agent-based reviewer/continuation route — the trust decision is the main agent'sWebFetch, and it must not be delegated to a shard.
🔒 Do not wrap this skill in
/loop,/schedule, orCronCreate. It is verdict-bearing — it emits a per-reference verdict that gates.bibedits (an evidence instrument, not a cross-model acquittal; see the acceptance-gate note in Step 2). Re-running it on a timer adds no signal (the verdict changes only when the bibliography changes). Schedule the external wait that precedes it: bibliography finalized → run once. See../shared-references/external-cadence.md.
citation-audit)citation-audit is a single cross-model reviewer that judges three things holistically:
existence, metadata, and context-fit (is the cited paper used for a claim it
actually supports?). This skill does not do context-fit. It does one thing that a
single reviewer cannot do reliably: an adversarial, field-level diff (double-blind when the host can isolate the web agent, a labelled flag-only heuristic otherwise)
of the local .bib entry against an independently reconstructed record.
The failure mode it targets is the hand-entry error that survives a plausibility read:
a dropped or re-ordered author, a wrong year, a swapped venue, a DOI that
404s. A single reviewer that sees the .bib entry tends to anchor on it and rate it
"looks correct." Two agents that never see each other's output cannot anchor — a
discrepancy only survives if both independent records agree, and the verifier reports
exactly where they diverge.
In practice it catches dropped/re-ordered authors, wrong years, and bad DOIs that a
single-pass audit rated "looks clean" — while NEEDS_WEBCHECK stops it from
false-flagging a legitimate non-arXiv (blog / tech-report) citation as fabricated. Use it
in addition to citation-audit, not instead: citation-audit protects your review
score (context-fit); this protects
against the integrity red flag of a wrong or fabricated reference (existence + fields).
citation-audit | citation-crosscheck (this) | |
|---|---|---|
| Owns | existence + metadata + context-fit | existence + field accuracy, adversarially |
| Method | one cross-model reviewer | two extractors (blind when isolation is attested) + a mechanical field-diff |
| Reads the .tex claims? | yes | no (bibliographic only) |
| Deliverable | KEEP/FIX/REPLACE/REMOVE per entry | side-by-side .xlsx + MATCH/MINOR/MISMATCH |
| Best at catching | wrong-context citation | dropped/re-ordered author, wrong year/venue/DOI |
dedup_key (a run-local ordinal that carries no
bibliographic content), and MUST NOT read the .bib or any repo file. B attests
blind:true only when the host isolates its context so it cannot inherit the .bib
(see the mirror-adaptation note above); otherwise B attests blind:false and the Step-3.5
gate certifies nothing (flag-only). Do not relax the prompt restriction, and never assert
blind:true without real isolation — an un-isolated blind:true is the one thing that
defeats the whole cross-check./abs/<id>, /bibtex/<id>), DBLP, CrossRef, ACL Anthology,
NeurIPS/PMLR proceedings, OpenReview. Report what the fetched page shows; never
fabricate a field.MATCH (bibliographically equivalent, cosmetic-only) / MINOR
(formatting or a preprint-vs-published venue, no correction required) / MISMATCH
(real discrepancy: wrong/missing author, wrong year, wrong venue, wrong id) /
NEEDS_WEBCHECK (B could not confirm existence, but the entry is a
@misc/blog/tech-report whose url B's index-based search structurally cannot see —
the main agent must fetch that url in Step 4 before any verdict; never downgrade
such an entry straight to MISMATCH)..bbl); --all also
covers uncited .bib entries.<paper-dir>/citation_crosscheck_<date>.xlsx (+ the four intermediate JSONs —
cx_A_ourbib, cx_B_web, cx_C_fielddiff, and the gate's cx_gate.json — kept for audit).# Search the paper's own source tree, not the whole repo: bundled author-kit /
# template .tex carry demo \cite{...} that inflate the set. Set PAPER_DIR to the dir of
# the main .tex (\documentclass + \bibliography); recurse (cites often live in
# sections/*.tex); exclude vendored/example dirs.
PAPER_DIR="<dir of the paper's main .tex>"
cd "$PAPER_DIR"
python3 - <<'PY'
import re, pathlib
# Skip vendored/example/template trees: bundled author kits carry demo \cite{...}.
# NOTE: this is a NAME match — a dir you *want* audited must not match (rename it or
# narrow SKIP), e.g. `examples_of_results/` would be skipped.
SKIP = re.compile(r'(?i)(^|/)(.*template.*|.*upstream.*|.*example.*|.*vendor.*)(/|$)')
# Verbatim-ish blocks AND inline \verb|...| / \lstinline are code samples, not citations.
VERB = re.compile(r'\\begin\{(verbatim|lstlisting|minted|Verbatim)\}.*?\\end\{\1\}', re.S)
# The optional arg may itself contain brackets: \lstinline[language={[LaTeX]TeX}]|...|
VERBINLINE = re.compile(r'\\(?:verb|lstinline)\*?'
r'(?:\[(?:[^\[\]]|\[[^\]]*\])*\])?\s*'
r'([^\sA-Za-z])(?:(?!\1).)*\1', re.S)
# url/href/path args may contain a literal % that is NOT a comment. Neutralize them
# BEFORE comment-stripping, or a real \cite later on that line is silently lost.
URLCMD = re.compile(r'\\(?:url|href|path|nolinkurl)\s*\{[^{}]*\}')
COMMENT = re.compile(r'(?m)(?<!\\)%.*$')
# EXPLICIT ALLOWLIST of cite commands. Do NOT build this from a prefix/suffix pattern:
# a Cartesian `(no|paren|auto|...)?cite(s|p|t|...)?` both invents commands (\citecite,
# \parenciteyear -> fake keys from any brace arg) and misses real ones (\footfullcite,
# \volcite, \notecite). Longest-first so \footfullcite wins over \footcite.
# volcite-family: the FIRST brace arg is a volume/page, NOT a cite key.
VOLCITE = {'volcite', 'Volcite', 'pvolcite', 'Pvolcite', 'fvolcite', 'ftvolcite',
'svolcite', 'tvolcite', 'avolcite',
'volcites', 'Volcites', 'pvolcites', 'Pvolcites', 'fvolcites', 'svolcites',
'tvolcites', 'avolcites', 'ftvolcite', 'ftvolcites'}
NAMES = sorted({
# natbib / LaTeX core (capitalized variants are real natbib commands)
'cite', 'Cite', 'citep', 'citet', 'citealp', 'citealt', 'citenum', 'citeyear', 'citeyearpar',
'citeauthor', 'citefullauthor', 'Citep', 'Citet', 'Citealp', 'Citealt', 'Citeauthor',
# biblatex singular + plural
'parencite', 'Parencite', 'footcite', 'footcitetext', 'footcitetexts', 'textcite',
'Textcite', 'smartcite', 'Smartcite', 'supercite', 'autocite', 'Autocite', 'fullcite',
'footfullcite', 'notecite', 'Notecite', 'pnotecite', 'Pnotecite', 'fnotecite',
'citetitle', 'citeurl', 'citedate', 'autocites', 'parencites', 'textcites',
'smartcites', 'supercites', 'footcites', 'cites', 'Cites', 'nocite', 'nocites',
# aliases + field/list forms + bibentry — real biblatex/natbib families
'citetalias', 'citepalias', 'Citetalias', 'Citepalias', 'citefield', 'citelist',
'bibentry', 'fullciter',
*VOLCITE,
}, key=len, reverse=True)
# (?![A-Za-z]) stops \cite matching the \citeXYZ of an unknown command; the trailing run
# accepts any mix of [opt] and {grp} so \cites{k1}[note]{k2} yields BOTH keys.
CITE = re.compile(r'\\(?:' + '|'.join(map(re.escape, NAMES)) + r')\*?(?![A-Za-z])'
r'((?:\s*(?:\[[^\]]*\]|\{(?:[^{}]|\{[^{}]*\})*\}))+)', re.S)
# Strip [optional] args BEFORE reading brace groups, or a braced note like
# \cite[see {Smith} p.3]{k} contributes 'Smith' as a phantom key.
OPTARG = re.compile(r'\[[^\]]*\]', re.S)
GROUP = re.compile(r'\{((?:[^{}]|\{[^{}]*\})*)\}', re.S)
CMDNAME = re.compile(r'\\([A-Za-z]+)')
# \addbibresource[opts]{x.bib} takes an optional arg; \bibliography{a,b} may list several.
BIBRES = re.compile(r'\\(?:bibliography|addbibresource)\s*(?:\[[^\]]*\])?\{([^}]+)\}')
keys, bibs, nocite_all = set(), [], False
for p in sorted(pathlib.Path('.').rglob('*.tex')):
if SKIP.search(str(p.parent)):
continue
src = p.read_text(errors='replace')
src = VERB.sub(' ', src)
src = VERBINLINE.sub(' ', src)
src = URLCMD.sub(' ', src)
src = COMMENT.sub('', src)
for res in BIBRES.findall(src):
bibs += [r.strip() for r in res.split(',') if r.strip()]
for m in CITE.finditer(src):
raw_cmd = CMDNAME.match(m.group(0)).group(1)
cmd = raw_cmd.lower()
grps = GROUP.findall(OPTARG.sub(' ', m.group(1)))
if raw_cmd in VOLCITE and len(grps) > 1:
# volcite takes {volume}{key}; the PLURAL volcites alternates
# {vol}{key}{vol}{key}... — so keep the odd-indexed args, not just grps[1:],
# or the second volume number is harvested as a phantom key.
grps = grps[1::2]
elif raw_cmd in ('citefield', 'Citefield', 'citelist', 'Citelist',
'bibentry') and len(grps) > 1:
# These commands take a single key(s) arg. If a stray second brace group
# follows (a defensive read of an ambiguous source), do not harvest it as a
# phantom key ('\citelist{k}{publisher}' -> just 'k', not '{k, publisher}').
grps = grps[:1]
for grp in grps:
toks = [''.join(g.split()) for g in grp.split(',')]
# \nocite{*} AND \nocite{*,named}: the wildcard renders EVERY bib entry.
if cmd.startswith('nocite') and '*' in toks:
nocite_all = True # see the NOCITE_ALL note below
for k in toks:
if k and k != '*':
keys.add(k)
print(f"BIB_RESOURCE={bibs[0] if bibs else '(none found - use the fallback below)'}")
print(f"BIB_RESOURCES_ALL={bibs}")
print(f"NOCITE_ALL={nocite_all}")
print(f"CITED_KEY_COUNT={len(keys)}")
import pathlib
# Persist the harvest so the shell can read it back deterministically (the heredoc only
# PRINTS to stdout; it cannot set a parent-shell variable).
pathlib.Path('/tmp/cx_cited_keys.txt').write_text('\n'.join(sorted(keys)))
pathlib.Path('/tmp/cx_cited_count.txt').write_text(str(len(keys)))
print('\n'.join(sorted(keys)))
PY
# Set $CITED_KEY_COUNT as a REAL shell variable (Step 3.5 passes it as --expect): the
# heredoc above only prints it, so read it back from the file the harvest just wrote.
CITED_KEY_COUNT=$(cat /tmp/cx_cited_count.txt)
Cross-check against a compiled main.bbl by KEY SET, not count: a count match with a
substituted key still hides a harvest miss (drop one real cite, gain one stray → same count).
Extract the rendered keys and diff the sets:
# \bibitem[label]{key} (natbib/plain) OR \entry{key}{type}{} (biblatex) — key is the first
# brace group either way. Empty diff = harvest and .bbl agree.
grep -oE '\\(bibitem|entry)\*?(\[[^]]*\])?\{[^}]+\}' main.bbl 2>/dev/null \
| sed -E 's/.*\{([^}]+)\}$/\1/' | sort -u > /tmp/cx_bbl_keys.txt
comm -3 <(sort -u /tmp/cx_cited_keys.txt) /tmp/cx_bbl_keys.txt # any output ⇒ investigate
The .bbl cross-check is conditional — an uncompiled submission has none. When absent,
confirm CITED_KEY_COUNT is plausible for the paper's length before proceeding; the
Step-3.5 manifest is the load-bearing coverage guard either way.
If NOCITE_ALL=True the .tex harvest is NOT the citation set. \nocite{*} renders
every entry in the .bib, so under the default cited-only SCOPE the set becomes all
entries that render: take the keys from the compiled .bbl when one exists, else from the
.bib itself (equivalent to --all), and say so in the report. Do not proceed on the
\cite-only harvest — it under-audits by exactly the uncited entries.
BIB_RESOURCES_ALL lists every \bibliography/\addbibresource found, in sorted-path
order; BIB_RESOURCE is just the first. If the list has more than one entry, pick the one
the main .tex declares rather than trusting the ordering, and audit the union only if
the paper really loads several. If BIB_RESOURCE comes back empty (e.g. a \input-flattened
submission), fall back to the largest *.bib under the paper dir and, when a compiled
main.bbl exists, read the cited keys from its \bibitem{...} entries instead of the .tex
(the .bbl is the ground truth for what actually rendered).
Produce the ordered list of cited keys and, for each, its title + first author (the
only thing agent B is allowed to see). Confirm every key exists in the .bib. Assign each
entry a stable opaque ordinal dedup_key (01, 02, … in resolved order): this is the
canonical id that joins the shards downstream. A receives dedup_key + the cite key; B
receives dedup_key + title + first author only (never the cite key or .bib text), so
the join key never leaks the blind side. Write two artifacts for the Step-3.5 gate, in
resolved order: /tmp/cx_dedup_keys.txt (the ordinal set, whitespace-separated) and
/tmp/cx_keymap.tsv (one dedup_key<TAB>cite_key line per entry — the ordinal→cite-key
pin). Step 3.5 builds a coverage manifest (ordinal → cite key → title hash) from
/tmp/cx_keymap.tsv + the .bib and verifies A against it as a mapping, so a citation
dropped or substituted downstream fails the run — a bare count or ordinal-set check would
pass a substitution that keeps the count.
This is a read-only extraction fan-out in the sense of
../shared-references/fan-out-pattern.md: A
and B are two shards that only extract records (each returns an entries[] set keyed
by dedup_key — never by list position, never a B-visible cite key, never a quality
ranking). Each shard returns the {shard_id, entries:[{dedup_key, …}]} envelope of
../shared-references/fan-out-pattern.md, and the
executor runs the mechanical dedup_key join below before C. No shard assigns a
MATCH/MINOR/MISMATCH/NEEDS_WEBCHECK label at all — the main agent assigns all
four in Step 4 from C's field evidence, and only its own web-confirm edits the .bib.
Dispatch (tier-portable). On this host there is no Claude Agent tool, so the mainline's
Tier 1 (Workflow-concurrent) and Tier 2 (Agent) forms both degrade here: run A, then B, then
C one after the other, each in the freshest context the host can give. The join and the
field-diff are identical to the mainline. Blindness is not automatic here (see the mirror
adaptation note above): B sets blind:true only if its context provably did not inherit the
.bib, and blind:false otherwise — in which case Step 3.5 downgrades every accept to
ESCALATE and the run flags rather than certifies. B is prompted with only the
title+first-author list and is forbidden from reading any local file; but when B is not run in
an isolated context, that prohibition is not enforced (B could observe the parent's .bib
read, or A's output), which is exactly why an un-isolated B must attest blind:false and the
gate then certifies nothing. Isolation is the guarantee; the prompt restriction alone is not.
Breadth. The shard set is fixed at three by the design, not by a budget: two records are the minimum for a double-blind diff (one per provenance), and the third is the differ that must have produced neither. Breadth is not a swept parameter here, so there is no breadth/cost trade-off to bound — but note the ceiling: two independent records, not an ensemble.
Acceptance gate (provenance, per
../shared-references/acceptance-gate.md). This skill is not a loop and has no self-terminating accept gate; it runs once over a fixed citation set. Type-A (executor may self-judge): thededup_keyjoin balanced, every entry labelled, the.xlsxwritten. Type-B (merit — is the entry bibliographically correct): never delegated to a shard. AMISMATCHor aNEEDS_WEBCHECKresolution requires the main agent's own primary-source fetch — no fetch, no finding. AMATCH/MINORrests on the two independent records agreeing, without a third fetch; that is weaker evidence than a fetch, so read a no-flagMATCHas "two sources concur", not "verified against the publisher of record".Requirement (4) is discharged by the deterministic branch, not by a jury.
fan-out-pattern.mdadmits "a single cross-model jury step — OR a deterministic verifier gate"; this skill takes the second:scripts/cx_verify.py(Step 3.5) is an external process that decidesMATCH/MINORby declared normalization and fails closed toESCALATEotherwise — the same script and the same verdicts on this host as on the mainline.The limit, stated plainly: the accept path is mechanical and a
MISMATCHneeds the main agent's own primary-source fetch, but the executor still reads that page, so this skill does not deliver cross-model acquittal and does not replace one — which is why it is meant to run in addition tocitation-audit(a single cross-model reviewer), not instead of it. Never report aMISMATCH, least of all a fabrication finding, on shard text alone.
.bib; extract each cited entry verbatim
(brace-matched, no reformatting) → /tmp/cx_A_ourbib.json
{"shard_id":"A","entries":[{"dedup_key","key","bibtex"}]}. Explicit instruction: do not
search the web./tmp/cx_B_web.json
{"shard_id":"B","blind","entries":[{"dedup_key","title_queried","found","source_url","bibtex","sources_tried","note"}]}.
Explicit instruction: do not read any local file / .bib; set found:false + a note
if a paper cannot be confirmed; never fabricate a field.
blind attestation (set once, for the whole B shard). B sets blind:true only
if it ran in a context that could not have seen the .bib — a genuinely isolated
dispatch that did not inherit the main agent's history. If B cannot guarantee that
(e.g. it ran in the main context), it MUST set blind:false. The Step-3.5 gate refuses
to certify a MATCH/MINOR on any entry that is not blind-attested, so a false
blind:true is the one thing that would defeat the whole cross-check — never assert it
to "pass".found:false. B works from the title+first-author query only — it must NOT be handed,
and cannot use, the .bib entry's url field (that stays with the main agent's Step-4
webcheck). A citation being absent from arXiv is NOT evidence it is fake.sources_tried per entry (e.g.
["arxiv","crossref","semantic-scholar(429)","web"]) so a found:false from a
degraded search (a source was down or rate-limited) is distinguishable from a genuine
not-found. Note any source that failed/blocked in the entry's note.On return, the main agent joins A and B on dedup_key — every ordinal from Step 1 must
appear exactly once on each side. A missing or duplicated dedup_key, or an unbalanced count,
is a fail-closed stop (re-run the offending shard), never a silent drop or a positional
guess. This mechanical join replaces order-coupling and is judgment-free — it decides nothing
about any citation, only that the two extractions line up before C diffs them.
C extracts, it does not adjudicate. Computing a field-by-field delta is mechanical extraction; deciding that an entry is
MATCH(i.e. admitting it as correct) is the acceptance verdict, which../shared-references/fan-out-pattern.mdreserves for the executor. So C emits per-field evidence, not a per-entry verdict: for each field it reportssame/differs(with both values verbatim) /absent, plus the routing flags below. The main agent assigns every finalMATCH|MINOR|MISMATCH|NEEDS_WEBCHECKin Step 4 from that evidence. A shard that returns a verdict label is out of contract — the same ruleproof-checkerandresearch-litstate for their shards.
A third pass (a fresh-context run — this host grants no delegation tool) reads both JSONs — it
produced neither — and, on each dedup_key-joined pair, diffs the two records field by
field: title (ignore case/braces),
author set AND order, year, venue (NeurIPS ≡ "Advances in NIPS"; note a genuinely
different event), volume/pages, arXiv id / DOI. Output /tmp/cx_C_fielddiff.json:
{"shard_id":"C","entries":[{"dedup_key","key","blind","found","sources_tried","url","fields":{"<field>":{"status":"same|differs|absent","ours","web"}},"flags":[...]}]}
(found/sources_tried/blind copied verbatim from B, url from A, so Step 4 and the
gate can act without
re-reading the shard files)
(keyed by the joined dedup_key) plus a summary
{entries, fields_by_status:{same,differs,absent}, flags_by_type} — counts of mechanical
field states, not a verdict tally.
Critical routing flag for C (this prevents the most damaging false positive): if B
reports found:false for an entry whose A-side .bib type is @misc (or otherwise
carries a url/howpublished instead of an arXiv id / DOI), and B's sources_tried
shows it only queried indexers that cannot see that URL (arXiv/DBLP/etc.), C MUST attach
the flag url_only_source_unqueried — and MUST NOT report the entry as absent-from-web.
B's index-based method structurally cannot confirm a blog/tech-report citation; only the
main agent's direct url fetch in Step 4 can. C likewise attaches degraded_search when
sources_tried shows a source was down or rate-limited, and web_record_absent whenever B
returned found:false for any reason. These flags force the entry into the main agent's Step-4
queue; none of them is a finding about the citation — they record what B's search did, not
whether the reference is sound.
cx_verify.py, mandatory)This is the fan-out's requirement-(4) gate: fan-out-pattern.md demands "a single
cross-model jury step — OR a deterministic verifier gate — that is identical across all
three tiers." This skill has no cross-model jury, so the gate is an external process. It is the
same script and the same verdicts on this host as on the mainline — the dispatch of A/B/C
degrades by tier, the gate does not. The gate recomputes both the field diff and the routing
flags from A's and B's own raw records and reads B's blindness attestation from B directly;
C's flags are advisory only (unioned with the recompute) and a C schema violation fails
closed — so C is not in the trust path for the diff or the routing. Resolve $CX_VERIFY
with the Codex hybrid chain
(managed project install, in-repo checkout, ARIS repo fallback, then the copied global Codex
skill install). This is Policy A — skill-local gate:
Resolver note (owner-local, per
../shared-references/integration-contract.md).cx_verify.pyis a single-skill helper under this skill's ownscripts/, resolved via the Codex hybrid chain below. It deliberately ships notools/cx_verify.pyshim — it has no legacytools/entry to forward from (unlike the Phase-3 moves that kept one) — which is the owner-local Layer-0 exception the contract's Policy-A row registers.
CX_VERIFY=""
cd "$(git rev-parse --show-toplevel 2>/dev/null || pwd)" || exit 1
if [ -z "${ARIS_REPO:-}" ] && [ -f .aris/installed-skills-codex.txt ]; then
ARIS_REPO=$(awk -F'\t' '$1=="repo_root"{print $2; exit}' .aris/installed-skills-codex.txt 2>/dev/null) || true
fi
# Global pointer written by smart_update_codex.sh, for hosts with no per-project install.
if [ -z "${ARIS_REPO:-}" ] && [ -f "$HOME/.aris/repo" ]; then
ARIS_REPO=$(cat "$HOME/.aris/repo" 2>/dev/null) || true
fi
[ -f ".agents/skills/citation-crosscheck/scripts/cx_verify.py" ] && CX_VERIFY=".agents/skills/citation-crosscheck/scripts/cx_verify.py"
[ -z "$CX_VERIFY" ] && [ -f "skills/citation-crosscheck/scripts/cx_verify.py" ] && CX_VERIFY="skills/citation-crosscheck/scripts/cx_verify.py"
[ -z "$CX_VERIFY" ] && [ -n "${ARIS_REPO:-}" ] && [ -f "$ARIS_REPO/skills/citation-crosscheck/scripts/cx_verify.py" ] && CX_VERIFY="$ARIS_REPO/skills/citation-crosscheck/scripts/cx_verify.py"
[ -z "$CX_VERIFY" ] && [ -f ~/.codex/skills/citation-crosscheck/scripts/cx_verify.py ] && CX_VERIFY="$HOME/.codex/skills/citation-crosscheck/scripts/cx_verify.py"
[ -z "$CX_VERIFY" ] && {
echo "ERROR: cx_verify.py not resolved at .agents/skills/citation-crosscheck/scripts/, skills/citation-crosscheck/scripts/, \$ARIS_REPO/skills/citation-crosscheck/scripts/, or ~/.codex/skills/citation-crosscheck/scripts/." >&2
echo " The requirement-(4) gate cannot run; do NOT hand-assign MATCH/MINOR in its place. Fix: rerun install_aris_codex.sh, export ARIS_REPO, or copy the citation-crosscheck skill into ~/.codex/skills/." >&2
exit 1
}
python3 "$CX_VERIFY" --selftest || exit 1 # built-in cases; fail = do not trust the gate
# Build the coverage manifest (ordinal → cite key → title hash) from Step 1's ordinal PIN
# (/tmp/cx_keymap.tsv) + the .bib, using the gate's OWN parser. This is independent of A, so
# the gate can verify A against it as a MAPPING. ($BIB = the resolved .bib path from Step 1.)
python3 "$CX_VERIFY" --build-manifest --bib "$BIB" --keymap /tmp/cx_keymap.tsv \
--out-manifest /tmp/cx_manifest.tsv || exit 1
# The gate RECOMPUTES the field diff AND the routing flags from A's and B's own raw records
# (`web_record_absent` from B's `found`, `degraded_search` / `url_only_source_unqueried` from
# B's `sources_tried` + A's fields), and reads B's blindness attestation from B directly. C's
# flags are ADVISORY only, unioned with the recompute, and a C schema violation fails closed —
# so a faulty/omitting/adversarial C can neither hide a discrepancy, forge a MATCH, nor wave an
# entry through by omitting a flag. Coverage is MANDATORY: `--expect-manifest` verifies the
# ordinal→key/title MAPPING against A (catching a drop-and-substitute the ordinal-set check
# cannot); `--expect` / `--expect-keys` add the count and ordinal-set checks. An empty artifact,
# a duplicate/absent/substituted key, a dropped citation, or A/B/C key-sets that disagree all
# exit non-zero rather than reading as "clean".
python3 "$CX_VERIFY" --a /tmp/cx_A_ourbib.json --b /tmp/cx_B_web.json --c /tmp/cx_C_fielddiff.json \
--expect "$CITED_KEY_COUNT" --expect-keys /tmp/cx_dedup_keys.txt \
--expect-manifest /tmp/cx_manifest.tsv \
--json /tmp/cx_gate.json || exit 1
What the gate decides, and what it refuses to decide:
MATCH — every compared field equal after declared normalization (LaTeX accent/brace
folding, case, punctuation; an order-preserving surname list; a fixed venue-alias table).MINOR — the sole difference is preprint-vs-published venue for the same work.ESCALATE — everything else, fail-closed: any identifying field differing
(authors, year, title, doi, arxiv), a secondary field differing, an identifying
field absent on one side, a venue pair not in the declared table, any routing flag,
found != true, or an entry that is not blind-attested (blind != true). A
MATCH/MINOR that lacks the blindness attestation is downgraded to ESCALATE: the run
can still flag a discrepancy, but it may not certify a match. This is what enforces the
double-blind claim mechanically — a host that cannot dispatch B in isolation (so B might
have seen the .bib) sets blind:false and the gate refuses to certify anything, turning
the check into a labelled heuristic rather than a false certification.The gate never emits MISMATCH. A discrepancy becomes a finding only when the main agent
reproduces it against the publisher of record, so the accept path is mechanical and the reject
path is externally evidenced. Author order is preserved by the normalizer on purpose — a
re-ordered author list is one of the defects this skill exists to catch, so it must not
normalize to equal.
No verdict arrives pre-assigned from a shard. Read /tmp/cx_gate.json (the gate's recomputed
verdicts and per-field evidence) — C's cx_C_fielddiff.json is audit-only and must not
override the gate. The invariant of this step: every MATCH/MINOR/MISMATCH rests on
either (a) the gate's mechanical decision or (b) a completed main-agent primary-source fetch.
No shard signal — a differs, an absent, B's found:false, or a routing flag — is itself a
finding. Two exhaustive cases:
Gate said MATCH or MINOR → adopt it (case (a), mechanical). Do not re-litigate a
mechanical equality decision from prose, and do not silently upgrade it to MISMATCH; if you
believe the gate is wrong, the fix is the gate's normalization table plus a --selftest case,
not a hand-edit of one row. (What a no-flag MATCH means: two independently-produced records
concur — not "verified against the publisher of record".)
Gate said ESCALATE → the main agent MUST complete a primary-source fetch before it
may assign any of MATCH/MINOR/MISMATCH/NEEDS_WEBCHECK. This is a procedure, not a
first-match menu: do every applicable fetch, then decide — so no earlier branch can
preempt a stricter one.
Fetch. Identify and WebFetch the primary source(s):
url / howpublished whenever the .bib carries one — always for the
url_only_source_unqueried / web_record_absent cases (this is the .bib's url,
which B never saw); andDecide from what the fetch(es) returned — each terminal rests on a completed fetch:
.bib (title + author set/order + year + id agree) →
MATCH (annotate the source; for a url-confirmed non-arXiv entry note
"blog/tech-report, web-confirmed"). A gate differs/absent the source does not
reproduce is downgraded here, with the reason recorded.MINOR.MISMATCH, citing the fetched value. (Field-discrepancy
MISMATCH — the source reproduced it; this guards against a B/C hallucination inventing
a wrong "fix.")MISMATCH (fabrication) only when BOTH hold: the
entry's url is absent / dead / contradicting, and the main agent's own general
search also failed. A dead url alone, or B's found:false alone, is never enough
— this is the one path to a fabrication finding and it rests on the main agent's own null
result, not on B's miss.NEEDS_WEBCHECK,
left for a human. Never default an inconclusive fetch to MATCH or MISMATCH.A one-sided absent field is not resolved "from the fields both sides share": the gate
already escalated it, and the verdict comes from the fetched primary source per the ladder
above (an absence becomes MISMATCH only when the .bib asserts a field the source
contradicts; otherwise MATCH/MINOR per the fetch, with the absence noted in Detail).
Every entry leaves Step 4 with exactly one of the four labels, each MATCH/MINOR/
MISMATCH backed by the gate or a completed main-agent fetch. If an ESCALATE's evidence
fits none of the outcomes above, that is a fetch not yet done, not licence for a shard to
decide. Do not edit the .bib on shard evidence alone: every applied fix traces to a
main-agent fetch.
Build the .xlsx (openpyxl) with one row per citation and columns:
# | BibKey | Link | Our BibTeX | Web BibTeX | B source | Verdict | Author check | Year | Detail | Fix. Color the Verdict cell: green = MATCH, yellow = MINOR or a
NEEDS_WEBCHECK the main agent resolved to MATCH (annotate how), orange = MISMATCH.
Add a Summary sheet with the counts and the fixed/optional lists. Apply only the main-agent-confirmed MISMATCH
fixes to the .bib; if the paper is compiled, rebuild so the .bbl picks them up and
re-verify the page count is unchanged. Report MINOR items as optional (do not auto-apply
preprint→published upgrades; that is an author choice).
.bib, the cross-check collapses
into a single-source read and loses its power. Enforce it in the prompt.found:false + a note beats a guess.@misc/blog/tech-report/proceedings-URL
citations are legitimate and invisible to arXiv/DBLP search. B must try the general web
from the title+first-author prompt only; C flags an unconfirmed URL-bearing entry
(url_only_source_unqueried) and the main agent assigns NEEDS_WEBCHECK and fetches the
entry's own url in Step 4. A MISMATCH (fabrication) requires both a dead or
contradicting url and the main agent's own general web search also failing (per Step 4) —
a dead url alone is never enough. This is the skill's most dangerous false-positive if skipped.MATCH/MINOR/MISMATCH/NEEDS_WEBCHECK is assigned by the main agent in
Step 4, and every MISMATCH is web-confirmed by the main agent before the .bib is
touched. The shards propose; the main agent's own fetch disposes.citation-audit's job. Recommend running both before submission.Automatically, when a task matches. Use when user says "c
Skills that do similar work, with their headline benchmark lift.
From the same source and nearby in the catalogue.