name: conference-watch description: >- Watch and report on upcoming AI/ML conferences: submission deadlines (every stage), dates, location, special sessions / calls for papers, official links, and a 5-year acceptance-rate trend. Use when the user asks about future AI conference deadlines, wants to plan submissions, compare venues, or track a set of conferences by area/reputation/difficulty. Works in any agent that has a web-search / web-fetch capability (Claude Code, Codex, etc.). license: MIT metadata: version: 0.1.0

ConferenceWatch

Produce an accurate, well-sourced snapshot of the AI/ML conferences a user cares about — with every submission deadline stage, dates, location, special sessions / CFP, official links, and a 5-year acceptance-rate trend.

Two artifacts are always produced:

1. A JSON dataset (one object per conference) — the structured source of truth.
2. A human-readable Markdown report with a short summary.

Guiding principles

• Never invent dates. A deadline goes into the JSON only if you found it on an official/authoritative source. If you infer from historical patterns, mark it approximate and say so explicitly in the report.
• Cite everything. Every edition and every acceptance-rate number carries a source_links entry. Prefer official conference sites and CFP pages; use aggregators (see references) as leads, then confirm on the official page.
• Timezones matter. Record the raw deadline text (e.g. "May 22, 2026 AoE"). Most AI venues use AoE (Anywhere on Earth, UTC-12). Keep the AoE flag.
• Today is the anchor. Use the current date to decide which edition is "upcoming" vs "past". Do not assume the model's training-cutoff year.

Workflow

Step 0 — Establish the anchor date

Determine today's date (from the environment/context). All "future vs past" decisions are relative to it. State the anchor date in the report metadata.

Step 1 — Analyze input & narrow the scope

Parse the user's request for any of these filters:

• Area / topic — e.g. NLP, CV, ML theory, RL, robotics, HCI, systems, data mining, speech, multimodal, AI4Science.
• Reputation / tier — CORE rank (A*/A/B) or "top-tier only".
• Difficulty — proxied by acceptance rate (e.g. "only <25% venues").
• Named conferences — if the user already lists venues, skip to Step 2.
• Region / timing — e.g. "conferences with deadlines in the next 6 months", or "held in Europe".

If the request is under-specified, ask 1–3 concise follow-up questions to narrow it (offer sensible defaults so the user can decline easily). Example:

To focus the search, which of these should I use?

1. Area — all AI, or a subfield (NLP / CV / RL / …)?
2. Tier — top-tier (CORE A*) only, or include A/B venues?
3. Horizon — only deadlines in the next N months, or the full year? (If you'd rather not specify, I'll default to the top AI venues across areas.)

Default when the user declines or doesn't answer: the top general AI venues plus the leading venue(s) for any area they mentioned. See references/conference-catalog.md for the curated tier list to draw from.

Step 2 — Build the initial conference list (initial JSON)

From the filters, assemble the candidate list and write the initial JSON using the schema in references/json-schema.md and the template assets/conference-data.template.json. At this stage only metadata + conference names/areas/tier need to be filled; edition/deadline/trend fields are placeholders to fill in Step 3–4.

Confirm the list with the user briefly ("I'll investigate these N conferences: …") before the (potentially long) search phase, unless they asked you to just go.

Step 3 — Research each conference: the UPCOMING edition first

For each conference, search for the next (future) edition relative to the anchor date. Query patterns that work well:

• "<CONF> <year> call for papers", "<CONF> <year> important dates", "<CONF> <year> submission deadline", "<CONF> <year> paper deadline".
• Then open the official site / CFP page to confirm; aggregators can be stale or wrong.

When exact info is found, record in the conference's upcoming_edition:

• year, location (city, country; note if virtual/hybrid), venue if known.
• dates: conference start/end.
• deadlines: every stage — abstract registration, full paper, supplementary, rebuttal, author response, notification, camera-ready, workshop/tutorial proposals, etc. Keep the raw text + AoE flag + confirmed: true.
• special_sessions: special tracks, new-this-year themes, datasets & benchmarks track, position papers, findings, industry track, journal-to-conference, etc.
• call_for_papers_url and website.
• data_confidence: "confirmed" and source_links.

If no future edition is announced yet, leave upcoming_edition.data_confidence as "approximate" and fill it via inference in Step 4.

Step 4 — Historical anchor: last 5 editions → trend + inference

For each conference, gather the last 5 editions (most recent past years):

• Populate acceptance_rate_trend with {year, submissions, accepted, acceptance_rate, source} per year — as many of the 5 as are available.
• If the upcoming edition's deadlines were not found in Step 3, infer the approximate deadline window from the historical pattern (e.g. "abstract deadline has fallen in the third week of May for the last 4 years → est. ~mid-May <next_year>"). Write these into upcoming_edition.deadlines with confirmed: false and set data_confidence: "approximate". Always flag inferred dates clearly in both JSON and report.

Step 5 — Finalize JSON

Write the complete JSON to conferences.<anchor-date>.json (or a path the user specifies). Validate it against the schema: every conference has a name, tier, website; every deadline has a stage + confirmed flag; every trend/edition row that carries data also carries a source link.

Step 6 — Produce outputs

1. Answer directly in chat: a compact table or list of the most time-sensitive items (nearest deadlines first), plus the short summary.
2. Write the Markdown report using assets/report.template.md:
   • A 3–5 sentence summary synthesizing what you found (nearest deadlines, notable new tracks, acceptance-rate direction).
   • A per-conference breakdown (deadlines table, location, special sessions, links, acceptance-rate trend).
   • A clearly-labeled "Approximate / inferred" section for anything not confirmed.
   • A Sources list.

Output file naming

• Data: conferences.<YYYY-MM-DD>.json
• Report: conference-report.<YYYY-MM-DD>.md (Use the anchor date so successive runs are comparable / diffable.)

Quality checklist before finishing

• Anchor date stated; upcoming vs past decided against it.
• Every confirmed deadline has a source link; timezone/AoE captured.
• Inferred/approximate items are flagged in both JSON and report.
• Acceptance-rate trend covers up to 5 recent years with sources.
• JSON validates against the schema; report summary written.
• Missing data is shown as null with a note — never fabricated.

ConferenceWatch

An Agent Skill that watches upcoming AI/ML conferences and reports, for each one: submission deadlines (every stage), dates, location, special sessions / call for papers, official web links, and a 5-year acceptance-rate trend. It is written to be reusable across common coding agents that can search the web — Claude Code, Codex, and similar.

What it produces

Every run yields two artifacts:

1. conferences.<date>.json — the structured source of truth. One object per conference (keyed by acronym), each holding the upcoming edition (deadlines, location, special sessions, links) and a 5-year acceptance-rate trend. Schema: references/json-schema.md.
2. conference-report.<date>.md — a human-readable report with a short summary, a nearest-deadlines table, a per-conference breakdown, and a clearly separated "approximate / inferred" section. Template: assets/report.template.md.

The agent also answers directly in chat with the most time-sensitive items.

How to use

Install (Claude Code)

One command installs it as a personal skill by cloning directly into Claude's skills directory:

git clone https://github.com/Zsun79/ConferenceWatch.git ~/.claude/skills/conference-watch

If you already cloned the project somewhere else, link that local checkout into the skills directory instead:

mkdir -p ~/.claude/skills
ln -s /path/to/ConferenceWatch ~/.claude/skills/conference-watch

For a single project instead, clone or link it into .claude/skills/conference-watch inside that project:

mkdir -p .claude/skills
ln -s /path/to/ConferenceWatch .claude/skills/conference-watch

Then just ask naturally:

> What are the deadlines for the top NLP conferences in the next 6 months?
> Track NeurIPS, ICML, and ICLR 2026 for me.
> Compare the top-tier CV venues by acceptance rate and next deadline.

The skill activates from its description when your request matches.

In Codex / other agents

This skill is plain Markdown + JSON, so it is agent-agnostic. Either:

• Point the agent at SKILL.md as its instructions for the task, or
• Paste the SKILL.md workflow into the agent's prompt/rules.

Requirement: the host agent must have a web search / fetch capability (and, to save files, filesystem access). No API keys or build step required.

Example prompts

• "List the top 5 AI conferences with deadlines before end of 2026."
• "I work in computer vision — track the A* venues and show acceptance-rate trends."
• "Just give me the top conferences, I don't want to specify an area." (uses defaults)

How it works (workflow)

The full logic lives in SKILL.md. In short:

flowchart TD
    A[Anchor on today's date] --> B[Analyze request and narrow scope]
    B --> C{Named venues or clear filters?}
    C -- No --> D[Ask 1-3 follow-up questions<br/>or use top-venue defaults]
    C -- Yes --> E[Build initial conference JSON]
    D --> E
    E --> F[Confirm candidate conference list]
    F --> G[Research upcoming edition first<br/>official CFP and important dates]
    G --> H[Collect every deadline stage,<br/>location, sessions, and links]
    H --> I[Gather last 5 editions<br/>acceptance-rate trend]
    I --> J{Upcoming dates confirmed?}
    J -- Yes --> K[Mark confirmed with sources]
    J -- No --> L[Infer approximate window<br/>from historical pattern]
    K --> M[Validate JSON]
    L --> M
    M --> N[Write JSON dataset]
    M --> O[Write Markdown report]
    N --> P[Answer in chat<br/>nearest deadlines first]
    O --> P

1. Anchor on today's date — all "future vs past" decisions are relative to the current date, not the model's training cutoff.
2. Analyze the request & narrow scope — the agent asks 1–3 follow-up questions to filter by area (NLP/CV/RL/…), reputation/tier (CORE A*/A/B), difficulty (acceptance rate), and horizon. If you decline, it defaults to the top AI venues (see references/conference-catalog.md).
3. Build the initial JSON — the candidate conference list is written out first, then confirmed with you before the long search phase.
4. Research the upcoming edition first — searches official CFP/"important dates" pages, records every deadline stage, location, special sessions, and links; marks them confirmed with sources.
5. Historical anchor (last 5 editions) — builds the acceptance-rate trend and, when a future edition isn't announced yet, infers an approximate deadline window from the historical pattern — always flagged as approximate.
6. Output — validates the JSON, writes the Markdown report with a short synthesized summary, and answers in chat.

Core rule: never fabricate dates. Anything not on an authoritative source is either null (with a note) or clearly marked approximate/inferred.

Repository layout

ConferenceWatch/
├── SKILL.md                          # main skill: workflow + rules (entry point)
├── README.md                         # this file
├── references/
│   ├── conference-catalog.md         # curated venues by area/tier + source sites
│   └── json-schema.md                # JSON schema + field rules
└── assets/
    ├── conference-data.template.json # starting JSON structure
    └── report.template.md            # Markdown report template

Notes & limitations

• Deadlines and rankings change; the skill confirms on official sites and cites sources, but always re-check the CFP before submitting.
• Acceptance-rate numbers can differ by source (main track vs. all tracks); the skill records the source alongside each figure.
• Inferred future dates are estimates only — labeled approximate everywhere.
• ⚠️ Generated reports are marked PRIVATE classification by default; handle the output accordingly.