Who patent-disclosure-skill is for#
Chinese R&D engineers filing their first patent
Point the skill at your project directory, name the patent type, and it extracts candidate patent points, conducts a CNIPA prior art search, and drafts the disclosure document with required diagrams. The engineer reviews and iterates; each round creates a new versioned file with a revision log.
Skip if:
Skip if your target jurisdiction is outside China. The prior art search and disclosure templates are built for CNIPA, not USPTO or EPO filings. International filers need a different workflow for those jurisdictions.
IP teams accelerating engineer disclosure intake
Engineers generate a structured disclosure draft from their own project materials before submitting to the IP team. The team receives a document with prior art citations, diagrams, and patent points already identified, reducing the back-and-forth needed to reach a complete submission.
Skip if:
Skip if your engineering teams already produce structured disclosures with diagrams and prior art searches independently. This skill adds the most value at the initial disclosure drafting stage, before attorney review.
Patent practitioners decoding existing Chinese patents
Feed a patent number or PDF into reader mode and receive a plain-language summary: claims tree, terminology glossary, feature-to-description mapping, and a Canvas knowledge map in Obsidian. Multiple patents accumulate into a private knowledge base with cross-links and tag-based search over case history.
Skip if:
Skip if you need the full knowledge graph experience but cannot configure an Obsidian vault. The plain-output fallback mode works, but the cross-patent linking and relationship graph features require the vault.
Teams managing recurring CNIPA office action responses
Past cases are tagged by defect type and CNIPA law article, then stored in Obsidian. When a new examination notice arrives, the skill filters relevant cases by tag and generates a draft response. Teams with a growing case library can add optional vector search for semantic case retrieval.
Skip if:
Skip if you have only a handful of past cases. The case library delivers the most value with a substantive history of office actions and responses to draw semantic matches from.
The problem it solves#
Engineers who do the core technical work at Chinese technology companies rarely appear on the resulting patents. The barrier is not technical knowledge but procedural: extracting patentable claims from a codebase or design document, conducting a prior art search against the Chinese national patent database (CNIPA), and producing a disclosure document in the correct format for each patent type takes a workflow that most engineers have never been trained to do.
The tools that exist for this workflow are built for patent professionals, not engineers. Commercial patent drafting platforms require describing the invention in abstract terms, not pointing at a project directory. The result is disclosures that miss patentable angles, or engineers who simply do not file and lose credit for what they built.
How it solves it#
Patent point mining from project materials
Scans your project directory in priority order: documentation first, then source code. Converts .docx and .pptx files to Markdown before scanning so structured documents are fully readable. From those materials it identifies candidate patentable claims and presents them for review before drafting begins.
Three patent types: invention, utility model, and design
Drafts disclosures for all three CNIPA patent types with separate templates per type. Invention patents use Mermaid flowcharts for the required block diagrams. Utility model and design patents generate structural line-art or appearance line-art, including part numbering for utility models and multiple view angles for design patents.
CNIPA prior art search via official database
Searches the China National Intellectual Property Administration public announcement database (epub.cnipa.gov.cn) first, using a dedicated Playwright-based crawler aligned to the patent type. Falls back to web search if the CNIPA database returns no results. Prior art citations are written into chapter one of the disclosure.
Timestamped versioning with revision history
Every output file is named with the case name and a timestamp, so each iteration produces a new file rather than overwriting the previous version. Corrections and supplemental material merges create new timestamped copies alongside a revision conversation log, giving a full audit trail across multiple drafting rounds.
Patent plain-language reader with Obsidian knowledge graph
Converts patent PDFs or public numbers into plain-language notes covering the claims tree, terminology glossary, and feature-to-description mapping. Notes are saved to an Obsidian vault with Canvas knowledge maps, cross-patent relationship links, and configurable CSS for callout coloring. Multiple patents accumulate into a searchable private knowledge base.
Examination response drafting with case RAG
Stores historical office actions and responses in Obsidian with CNIPA law article tags. When a new examination notice arrives, it filters past cases by defect type and generates a draft response. Supports optional vector embedding for semantic case retrieval; the tag-filter path works without a vector model.
Strengths and trade-offs#
Strengths
- MIT licensed, free to self-hostThe tool carries an MIT license with no seat fees, API billing, or subscription. All processing runs locally on your own infrastructure. Compared to Solve Intelligence or Questel Patent Drafting, which price by seat or query volume, self-hosting this skill costs only the server time you would use anyway.
- Works from actual project artifacts, not retrospective descriptionsInput is your project directory: source code, documentation, CAD files. You do not need to describe the invention from memory. The skill reads the same materials the invention was built from, which reduces the risk of missing patentable angles that only appear in the implementation details.
- Built for the CNIPA system from the startPrior art search targets the CNIPA public announcement database by default, with patent type-aligned queries. Disclosure templates match CNIPA formatting requirements for each of the three patent types. This is not a generic drafting tool adapted for China: it was designed for the Chinese filing system specifically.
- 5,848 stars with active development and low open-issue countThe repository has 5,848 stars and 710 forks with only 8 open issues, reflecting active maintenance at a fast response cycle relative to community size. The project reached that adoption level within its first five months, indicating strong demand for this workflow in the Chinese developer community.
Trade-offs
- -China patent system onlyPrior art search and disclosure templates are built for CNIPA filings: invention, utility model, and design patents under Chinese law. USPTO, EPO, PCT, and other jurisdictions are not supported. Teams filing internationally need a separate tool or workflow for non-CNIPA filings.
- -Requires an AI agent host environmentThis is an AgentSkills-format skill, not a standalone application. It runs inside a compatible AI agent runtime. Setting up the skill requires configuring that host environment in addition to the Python 3.9+ and Playwright dependencies documented in the project's INSTALL.md.
- -Full patent reader experience requires ObsidianThe knowledge graph, Canvas maps, cross-patent linking, and callout CSS configuration depend on an Obsidian vault being configured. Without Obsidian, the patent reader falls back to a plain output directory, dropping the relationship-graph and multi-patent accumulation features.
patent-disclosure-skill vs alternatives#
patent-disclosure-skill vs Solve Intelligence
Solve Intelligence is an AI-powered patent drafting platform built for patent practitioners: it handles claims drafting, prior art analysis, and office action responses through a managed web interface with no self-hosting option. patent-disclosure-skill targets the earlier stage in the workflow: the engineer who has a working project but no prior art search and no disclosure document yet.
| Feature | patent-disclosure-skill | Solve Intelligence |
|---|---|---|
| License | MIT | Proprietary SaaS |
| Self-hosting | Yes | No |
| Target user | R&D engineers | Patent attorneys |
| Patent system | CNIPA (China) | Multi-jurisdiction |
| Input method | Project scan (code, docs, CAD) | Text descriptions |
patent-disclosure-skill is the stronger choice when your priority is generating a disclosure from an actual codebase, keeping all materials on your own infrastructure, and working within the Chinese CNIPA filing system. Solve Intelligence is worth considering when you need attorney-grade claims language, multi-jurisdiction filing support, or a fully managed platform with no Python or Playwright dependencies to configure.
patent-disclosure-skill vs Questel Patent Drafting
Questel Patent Drafting is a commercial patent management suite that includes AI-assisted drafting for patent professionals in law firms and corporate IP departments. It is designed for practitioners who already understand patent claims language and need speed in producing office-ready documents.
| Feature | patent-disclosure-skill | Questel Patent Drafting |
|---|---|---|
| License | MIT | Proprietary |
| Self-hosting | Yes | No |
| Jurisdiction | CNIPA (China) | Multi-jurisdiction |
| Input method | Project scan (code, docs) | Manual drafting input |
| Cost | Free (self-hosted) | Subscription |
For Chinese engineering teams generating disclosures from technical artifacts, patent-disclosure-skill covers the full workflow from project scan to CNIPA-ready output at no licensing cost. Questel Patent Drafting is the better fit for IP departments that manage large patent portfolios across multiple jurisdictions and need integration with established patent management and docketing workflows.
What it's built on#
- Languages
- Python
FAQ#
Does patent-disclosure-skill support patents outside of China?
No. The skill is built specifically for the Chinese patent system. The prior art search targets the CNIPA public database, and the disclosure templates are formatted for CNIPA invention, utility model, and design patent filings. USPTO, EPO, and PCT workflows are not supported.
Is Obsidian required to use patent-disclosure-skill?
Obsidian is required only for the patent reader mode's knowledge graph features. The disclosure drafting workflow (the core use case) does not depend on Obsidian: outputs land in a timestamped files directory. Without Obsidian, the reader mode still produces notes but drops the Canvas maps, cross-patent links, and relationship graph.
What patent types does the skill support?
The skill supports all three CNIPA patent types: invention patents, utility model patents, and design patents. Each type uses a separate disclosure template with type-specific diagram generation. Invention patents are the default if no type is specified; the skill prompts to switch if the submitted materials look structural or appearance-focused.
How does the prior art search work?
The skill searches the CNIPA public announcement database (epub.cnipa.gov.cn) by default, using a Playwright-based crawler aligned to the patent type. If that search returns no usable results or encounters an error, it falls back to a general web search. Prior art citations are written into the first chapter of the disclosure document.
Is patent-disclosure-skill free to use?
Yes. The repository is MIT licensed, so you can run it on your own infrastructure at no cost. There is no subscription, per-query fee, or managed API to pay for. The only costs are the AI agent host environment you run it inside and the compute for the Python dependencies.
Similar open-source tools#
guaardvark
Self-hosted AI workstation with agents, video, voice, and RAG.
lumina
Local-first AI agent that learns, remembers, and never phones home
maka
Local-first AI agent workspace with append-only execution logs
berd
Self-hosted desktop app for AI agent work, model-agnostic by design.
rakazo
AI teammates you own: your keys, your model, your machine.
mex
Persistent memory and code graph for AI coding agents