Skip to content
English
Français English

What is Simon?

Simon is a French accounting application built around an AI agent. The idea fits in one sentence: Simon does the accounting work, and only comes back to you for what it cannot guess — your documents, your knowledge of the ground truth, and your approval on the decisions that commit you. The experience aims to feel like an attentive accountant: it handles the heavy lifting, only reaches out when it genuinely needs you, and leaves you with as little work as possible.

So you keep control of what matters. You upload the documents, you approve the proposals, you settle the ambiguous cases, and you are the one who files the returns with the tax authorities. Simon prepares and checks; it does not sign in your place.

Three principles

Your data stays with you

Simon runs on your machine. Documents, journal entries, views, company settings, workflow history: everything is stored locally, in the application’s data space. When the agent works, it sends the model you have chosen only the context needed for the task — and nothing is stored in a Simon cloud. That said, if that model is hosted by an external provider, it is that provider’s terms that apply to whatever transits through it.

You plug in your own AI

Simon does not sell a model. You connect the provider of your choice from the application, with your own API key or the subscription it offers. The selector then only shows the models that are actually usable — in particular those able to read attachments. See AI model configuration.

Simon works, you decide

This is the guiding principle. Simon is not one more piece of software to learn to operate: the logic is reversed — it does as much as possible for you and narrows your involvement down to the strict minimum. It reads the documents, prepares the entries, reconciles the payments, prepares the returns — and only asks you for a missing document, a piece of information only you can know, or a judgment call to approve. You talk to it in plain language, like you would to your accountant; the graphical interface, for its part, is there to review, check and correct what it has prepared.

You can even ask it for what the standard screens don’t show. “Build me a cash-flow dashboard with the invoices to collect and to pay,” and the agent composes a custom view — queries, tables, KPIs, charts — that is saved in your workspace. Once created, the view joins the agent’s context: it sees the description and can reuse it as a working base for its later analyses.

Who it’s for

Simon is aimed at the directors of French SARL, SAS, EURL, SASU or sole proprietorships under the standard (réel) regime, and more broadly at any small business that wants to keep its books up to date as it goes rather than discovering everything at year-end. It suits a company picking up an existing set of books from a FEC file just as well as an accountant or advisor who wants to delegate the repetitive tasks while keeping the final review.

What Simon handles

Simon covers the chain of a set of books kept inside the application, from the raw document to the tax obligations:

  • Ingestion — reading invoices, expense reports, bank statements, payslips, tax notices and other uploaded documents.
  • Qualification — the accounting and tax nature of an expense: category, professional share, recoverable VAT, applied rule.
  • Bank reconciliation — matching transactions to documents, including the non-trivial cases: grouped payment, partial settlement, shareholder current account, cash.
  • Posting — generating the journal entries from qualified and reconciled documents.
  • Lettering — matching the debit/credit lines of a same third party to track settled invoices and open balances.
  • Customer invoicing — generating invoices in the Factur-X format (PDF with embedded structured XML), numbered and ready to post.
  • Returns — tracking the obligations derived from the tax configuration: VAT (CA3, CA12, 3514 instalments), tax bundle and corporate tax (2065, instalments and balance), filing of accounts, DAS2 or DECLOYER where applicable.
  • Year-end closing — depreciation, provisions, cut-off, closing entries, reversals, allocation of earnings and opening balances.
  • FEC import — importing history, mapping journals, accounts and third parties, attaching supporting documents, consistency checks.
  • Documentary research — answers to rule questions backed by a base of BOFiP fact sheets and official tax instructions, with sources cited.
  • Steering — monitoring views: cash, payables and receivables, VAT, blocked documents, trial balance, general ledger, returns.

What Simon does not do (yet)

  • It is not a chartered accountant. Simon helps produce and check the books, but does not sign the accounts and bears no professional liability.
  • It is not an e-filing service. Simon prepares the data and the documents; transmission to the authorities remains on your side.
  • It does not connect to your bank. You import the statements or files; there is no automatic bank aggregation.
  • It is not (yet) an electronic-invoicing platform in the sense of the e-invoicing reform — customer invoicing exists, but not the reception/transmission of electronic invoices.
  • It is not a multi-user SaaS. The application is designed for a single workstation and a local database.

And how does it work, concretely?

One design point is worth highlighting: the agent is the actuator, not the source of truth. It diagnoses the state of the file, picks the right treatment, proposes the sensitive decisions to you, then executes once you have approved. Nothing bypasses the accounting rules, and everything stays on your machine.

flowchart TD
    User(["You<br/>approve the decisions"])


    subgraph Work["Run the accounting"]
        Agent["AI agent<br/>diagnoses and proposes"]
        UI["Graphical interface<br/>review and correct"]
    end


    MCP{{"Shared business layer<br/>accounting rules + validations"}}
    Local[("Local foundation<br/>accounting rules, SQL database, files")]


    User --> Agent
    User --> UI
    Agent --> MCP
    UI --> MCP
    MCP --> Local


    classDef user fill:#0f172a,stroke:#0f172a,color:#ffffff;
    classDef client fill:#eff6ff,stroke:#93c5fd,color:#0f172a;
    classDef contract fill:#dbeafe,stroke:#2563eb,color:#0f172a;
    classDef local fill:#f8fafc,stroke:#94a3b8,color:#334155;


    class User user;
    class Agent,UI client;
    class MCP contract;
    class Local local;

To go further: How Simon works lays out the mental model from the user’s side, and the Under the hood section explains the technical choices — the agent-first approach, the workflow and MCP symmetry.