Paperasse: the skill that makes AI agents useful for French paperwork

·16 min read
Updated on May 27, 2026

There is one category of work everyone underestimates until it blocks the company: paperwork.

Not paperwork in the abstract. Real paperwork. The FEC file you must be able to produce cleanly in France. Invoices with the right mandatory fields. VAT rules that depend on the company's regime. Annual closing, with journal entries, supporting documents, provisions, depreciation, deadlines and checks. Co-ownership documents. Estate questions. Reviews before a file is handed to the accountant, notary or statutory auditor.

That is exactly the ground covered by Paperasse, an open-source project created by Romain Simon.

I want to say it clearly from the start: thank you, Romain. Paperasse is one of those projects that makes AI agents much more concrete. Not because it claims to replace a regulated professional. It does not. The repository explicitly says the skills do not replace a certified accountant, statutory auditor or practicing notary. But it gives agents a much more serious business frame than "answer like an expert".

I also made a small contribution to the repository, a documentation PR about manual installation and symlinks. Nothing heroic, but useful. And it is a good metaphor for the whole topic: with AI agents, value often sits in the small details that prevent a promising system from breaking when someone tries to use it for real.

This article is not just a presentation of Paperasse. It is a practical reading guide for an SMB owner, consultant, accountant or admin team asking: "Can this kind of skill actually help us, and how do we install it without creating risk?"

What Paperasse is, in plain terms

Paperasse is a collection of skills for AI agents specialized in French bureaucracy.

In this context, a skill is a folder that contains at least one SKILL.md file. That file tells the agent when to use the skill, which role to adopt, which steps to follow, which sources to check, which guardrails to apply and, sometimes, which scripts or reference files to use. In Claude and Codex, the idea is to load specialized instructions when the task calls for them, instead of stuffing all expertise into a giant prompt.

The Paperasse repository contains domain skills such as:

Skill Role covered Practical value
comptable Accounting, tax, invoicing Journal entries, VAT, corporate tax, closing, FEC, tax bundle, e-invoicing
controleur-fiscal French tax audit simulation Identify possible reassessment areas and risk bases
commissaire-aux-comptes Annual accounts audit Check FEC, balance sheet, profit and loss, trial balance and tax return
fiscaliste Personal taxation Income tax, wealth tax, PFU, life insurance, LMNP, BSPCE, crypto, PER
notaire Real estate law, estates, gifts Notary fees, deeds, SCI, inheritance, ownership splits
syndic Co-ownership management General meetings, calls for funds, charges, works, arrears

As of 27 May 2026, the GitHub README lists these six skills. The agentskill.sh Paperasse skillset page showed five included skills in version v1.2.0. That detail matters: before building a client workflow on a skillset, verify what is actually installed in the agent environment. A registry, a GitHub repository and a local install can be slightly out of sync.

The strength of the project is not only that it gives the agent professional role names. Paperasse also includes data, scripts, templates and integrations. The README mentions Qonto and Stripe connectors, scripts to generate FEC files, financial statements and PDFs, plus documented sources for the French Chart of Accounts, tax return nomenclature, BOFiP, Sirene and public APIs useful for notarial work.

That is where Paperasse becomes interesting for an SMB: we are no longer talking about a generic chatbot conversation. We are talking about an agent that works with explicit business context, files, rules, scripts, sources and warnings.

Why this is not just a better prompt

It is tempting to think a skill is simply a prompt saved in a file.

That would miss the point.

A generic prompt often says: "Act like an accountant." A well-designed skill says instead: "Here is the exact scope of the role, the work sequence, the sources to use, the cases where you must stop, the files to read, the scripts to call, the data to verify, the legal limits and the expected output formats."

That difference changes everything.

A generic prompt works when the task is simple, short and low-risk. Rewriting an email. Summarizing a document. Explaining a concept. Drafting a list of ideas.

A skill becomes useful when the task is:

  • recurring,
  • structured,
  • tied to a profession,
  • sensitive to mistakes,
  • dependent on official sources,
  • composed of several steps,
  • linked to local files or tools.

Paperwork checks every box.

When a business owner asks "prepare my annual closing", the useful answer is not a reassuring wall of text. The agent must know what information to ask for, which documents to read, which checks to run, which entries to prepare, which areas to leave to a human, which outputs to generate and which limits to display.

Paperasse formalizes that frame.

This is exactly the logic I use in AI agent projects for companies. A useful agent is not a more talkative model. It is a system that knows where it works, with which data, under which rules and with which human approval.

The SMB use case: prepare, check, hand over

The best use of Paperasse for an SMB is not to let an agent "do the accounting" alone.

That would be the wrong promise.

The right use is more sober and much more useful: prepare, check, hand over.

Here are three examples.

1. Preparing the accountant meeting

An SMB often arrives at its accountant with scattered information: bank exports, invoices, supporting documents, internal notes, VAT questions, customer payments, Stripe payments, Qonto transactions, poorly categorized expenses.

An agent equipped with Paperasse can help:

  • list missing documents,
  • classify expenses from an export,
  • flag ambiguous transactions,
  • prepare precise questions for the accountant,
  • generate a summary of points to validate,
  • avoid sending an incomplete file.

The value is not replacing the accountant. The value is arriving with a cleaner, clearer file that takes less effort to process.

For a small company, moving from "everything is somewhere in my files" to "here are the points ready for review" can change the quality of the conversation with the professional.

2. Checking e-invoicing readiness

Paperasse also covers invoicing topics, including France's 2026 e-invoicing reform, accredited platforms, e-reporting, Factur-X, UBL and CII.

For an SMB, the right use case is not to ask: "Which platform should I choose?" in one question.

The right use case is to make the agent work on the process:

  • where are customers created?
  • is the SIREN present?
  • are delivery addresses reliable?
  • does the quote become an invoice without manual re-entry?
  • are payment statuses tracked?
  • are reminders logged?
  • are exports usable by the accountant?

This directly extends my article on France e-invoicing 2026 for SMBs. The reform is not only a software topic. It is a data flow topic.

Paperasse can help the agent ask the right questions, but workflow automation is still needed to connect the real tools: CRM, invoicing, banking, messaging, document storage and tracking dashboards.

3. Pre-auditing a file before a sensitive action

An agent equipped with the controleur-fiscal or commissaire-aux-comptes skill can simulate a control mindset on a file.

Again, this requires caution. It is not certification. It is not a binding opinion. It is not a regulated professional with liability.

But as preparation, it is valuable.

Before annual closing, fundraising, an accountant change, an announced control, a handoff to a statutory auditor or a patrimonial operation, the agent can flag blind spots:

  • inconsistent accounts,
  • missing supporting documents,
  • unusual entries,
  • shareholder current accounts to clarify,
  • VAT to verify,
  • poorly documented fixed assets,
  • areas where human validation is mandatory.

The useful output is not "everything is fine". The useful output is a prioritized list of points to review with a professional.

That is exactly the type of advanced use case my target market searches for: an SMB that does not want to gamble with compliance, but wants to use AI to prepare administrative work better.

Where Paperasse fits with Claude, Codex, OpenClaw or Hermes

Paperasse is written in Markdown. That matters.

The repository says the skills work with any agent or tool capable of reading files. The README mentions Claude Code, Claude Cowork, Codex, Mistral Vibe, Cursor, Windsurf, Cline and Aider.

This deserves to be explicit: Paperasse is not limited to Claude or Codex. Because the core of the skill is Markdown that an agent can read, it can also be used with Mistral, with Mistral Vibe, or with an agent backed by a local model, as long as the environment knows how to load the skill files, read its resources and run any scripts when needed. The model matters, of course. But the real issue is the execution environment: access to the right files, data isolation, limited permissions and traces.

In practice, I see three levels of use.

Level Use Example
Personal assistant You use Paperasse inside Claude or Codex to prepare documents and ask better questions A business owner asks for a document review before an accountant meeting
Work agent The agent has access to folders, scripts, exports and local rules Codex reads an export, applies a skill, generates a summary and flags uncertainty
Connected agent The agent is connected to business tools and approval channels OpenClaw or Hermes receives a request, fetches data, prepares an action, then waits for approval

The third level is the most interesting to me professionally.

An OpenClaw assistant or a Hermes agent becomes much more useful when it does not merely answer in natural language. With a skill like Paperasse, it can understand a French administrative context, ask the right questions, prepare a document, warn about limits and fit into a workflow.

Simple example: a business owner sends a Slack or WhatsApp message saying "prepare the points to check before my annual closing". The agent retrieves available exports, uses Paperasse to structure the analysis, prepares a summary, flags risky areas and asks for human approval before any external transmission.

That is very different from a chatbot improvising an answer.

It is also why Paperasse has real SEO and commercial value for my positioning. It connects several topics I already cover: AI agents, automation, n8n, self-hosting, human approval, e-invoicing and business workflows.

The installation checklist I would use before relying on it

Installation looks simple. The README offers two main options: agentskill.sh or GitHub.

agentskill.sh deserves its own note. Romain Simon also launched it to create a centralized registry of skills, but not only for search convenience. The site also documents quality scores, security audits, installation through /learn, version tracking with content hashes and checks before installation. That matters because a skill can ask an agent to read files, run commands, call scripts or handle sensitive data. Installing a random skill from GitHub is therefore not a neutral action.

But details matter.

My PR to Paperasse, merged on 13 May 2026, documents one specific point: some shared folders are referenced through symlinks. If an installer downloads skill folders one by one through the GitHub API, it can turn these symlinks into small text files. The skill may appear installed, while workflows that read data, scripts, templates or integrations fail.

That is not cosmetic. It is exactly the kind of issue that makes a user lose trust: "the agent told me it was installed, but nothing works."

For a serious installation, I would verify:

Check Why it matters
Installation method A full Git clone preserves symlinks better than folder-by-folder downloads
Installed scope Verify whether five or six skills are actually present depending on the source
Shared files data, scripts, templates, integrations and company.example.json must be accessible
Sensitive variables Qonto, Stripe or other keys must stay in environment variables, not prompts
Company data The configuration file must be treated as a sensitive document
Basic tests Run a low-risk task before using a real file
Logging Keep track of files read, outputs produced and human approvals

For Codex, the documentation added to Paperasse recommends keeping shared resources at the same level as skill folders. That is exactly the kind of convention I would document in a client deployment.

And in an SMB context, I would not stop at "the skill is installed". I would also verify that the team knows when to use it, which data it can provide, which data it should not provide and when to escalate to the right professional.

Guardrails before connecting real data

Paperwork often contains the most sensitive data in a business.

Invoices. Bank details. Bank transactions. Salaries. Dividends. Assets. Estates. Contracts. Disputes. Co-ownership files. Personal information.

An AI agent working on this data must be treated as a production system, not a toy.

Before connecting Paperasse to real data, I would set at least five guardrails.

1. Separate experimentation from production

Start with neutral, anonymized or fictional data. Check that the agent understands the workflow, finds the files, runs the scripts and produces readable outputs.

Only then move to real documents.

2. Limit permissions

The agent does not need to read everything.

For a first use case, I prefer a limited folder: one bank export, a few invoices, a list of questions, minimal company context. If the project grows, access can widen gradually.

3. Keep secrets out of prompts

Qonto, Stripe, OpenAI, Anthropic or other API keys should not be pasted into a conversation. They belong in environment variables, a vault, a secrets manager or an appropriate server configuration.

This is a simple rule, but it prevents a lot of damage.

4. Put the human in the right place

Paperasse can help prepare an entry, a summary, a check, a risk list or a draft document.

But actions that commit the company must still be approved: filing, customer sending, accountant handoff, declaration, invoice, payment, tax decision, signature.

I detailed this logic in my article on human approval for AI agents in production. It applies perfectly here.

5. Trace what happened

When the agent produces an administrative summary, you need to know:

  • which files were read,
  • which sources were used,
  • which assumptions were made,
  • which limits were flagged,
  • who validated,
  • which skill version was installed.

Without a trace, the agent can be convenient. With a trace, it becomes usable inside an organization.

What Paperasse reveals about AI agents in business

Paperasse shows a broader trend: useful AI agents will not only be better models. They will be models placed in better environments.

A general model knows many things, but it does not automatically know:

  • how your company invoices,
  • where your exports live,
  • which version of the French Chart of Accounts to use,
  • which internal rules apply,
  • who must approve,
  • which data is confidential,
  • which tools must be updated,
  • which output your accountant expects.

The skill brings part of the business context. The workflow brings orchestration. The infrastructure brings security. The human brings judgment.

The assembly creates the value.

This is also what separates a serious AI project from an attractive demo. In a demo, you ask: "Answer this accounting question." In an SMB, you ask: "Read this file, check what is missing, prepare a summary, show your sources, pause risky points, create a task for the responsible person and do not send anything without approval."

The second sentence is less flashy. It is much more useful.

What I would do to deploy Paperasse in an SMB

If an SMB asked me to install Paperasse in its environment, I would not start by copying files.

I would start with the use case.

The question is not: "Do you want an accounting agent?" The better question is: "Which administrative flow costs time, creates stress or comes back incomplete too often?"

Then I would follow a seven-step method.

Step Objective
1. Choose a narrow case Closing preparation, invoice review, document control, VAT questions, co-ownership file
2. Map the data Where files, exports, rules, access and responsible people live
3. Install cleanly Verify the skill, shared resources, scripts and actual available scope
4. Define limits What the agent can prepare, what it cannot decide, what requires approval
5. Build the workflow Input folder, analysis, output, notification, approval, archiving
6. Test on controlled real cases Compare outputs with human judgment and adjust rules
7. Train the team Explain when to use the agent, how to phrase requests and when to refuse

That is where my AI consulting and integration work becomes useful. The skill already exists. The question is how to insert it into an organization without exposing data, overpromising or creating a tool nobody uses.

For some companies, the right deliverable will be a well-configured Codex environment with folders, rules and scripts. For others, it will be an OpenClaw or Hermes assistant connected to Slack, WhatsApp, Drive, Qonto or a document space. For others, it will be an n8n workflow that prepares files and creates approvals.

The common point: the agent never works in a vacuum.

When Paperasse is not the right tool

Paperasse is useful, but it should not become a universal hammer.

I would not use it alone to:

  • make a binding tax decision,
  • respond to an ongoing audit without a professional,
  • draft a complex deed without a notary or lawyer,
  • arbitrate a dispute,
  • automatically submit declarations,
  • process sensitive data without an access framework,
  • replace an accounting firm.

I would use it to:

  • prepare files,
  • flag inconsistencies,
  • structure questions,
  • document points to validate,
  • accelerate information collection,
  • help a team communicate better with its advisors.

That distinction is essential.

An AI that claims to replace a regulated professional creates risk. An AI that prepares the professional's work better can create a lot of value.

Sources consulted

Sources consulted on 27 May 2026:

Conclusion

Paperasse matters because it gives a concrete shape to an idea many SMBs are still trying to name: AI becomes useful when it understands the profession, documents, rules, limits and workflow.

Thank you to Romain Simon for opening this path. French bureaucracy is an excellent field for AI agents precisely because it is structured, demanding, repetitive, stressful and full of cases where humans must remain in control.

For an SMB, Paperasse is not magic. It is a building block. Installed cleanly, framed properly and connected to the right tools, it can help prepare files, reduce omissions, improve communication with professionals and turn an AI conversation into a real administrative workflow.

And that is exactly the type of project I find most interesting: not decorative AI, but an agent that enters real work, respects constraints, shows its sources, asks for approval when needed and leaves the company more organized than it found it.

Also available: Read in French