The problem
Around 5,000 solo advisors, half their week lost to compliance paperwork.
France counts roughly 5,000 AMF-registered CIFs, most of them being solo practices. They operate under MiFID II with the compliance surface of an institution. This means they have to perform and be accountable for the following: suitability assessments, adequacy reports, regulatory justification narratives and a 10-year audit trail. While the paperwork can be absorbed as you scale, for individual advisors, it is literally taking more than half of their working time.
The tooling available to them is CRM-shaped (client files, task lists, document storage) but the regulated work, the analysis and the writing, stays manual.
When I started looking into the problem, I initiated a series of deliberately non-leading interviews with practicing CIFs. And more than confirming my assumptions it actually corrected them. While I expected reluctance about AI for regulatory reasons, they were already running AI agents with financial-lawyer and accountant personas. Doing most of the anonymization manually and scraping fund valuations from Yahoo Finance with AI-generated Python scripts (because the professional data feeds only pay off above roughly €10M under management). But their constraints were elsewhere. The client data could never reach an AI: “tout ce qui est public, je bombarde,” as one of them put it, everything public goes in, client files never. And when I asked about what would actually help, the answer was not yet another dashboard, it was to get more time: “si j’ai pas une assistante, il faut une IA.”
Those constraints are the product. CIFs need a tool that understands their regulatory obligations, handles the paperwork so they can advise, and leaves strategy where they insisted it belongs: with the human. That last part goes deeper than preference. The CIF is personally accountable for the advice they give. And an AI? Well… it can’t be accountable.
What was built
A back office where the AI does the regulated paperwork and the advisor keeps the authority.
Socle is aimed at facilitating the advisor’s operations by consolidating and automating fund universe management, client onboarding, portfolio construction, adequacy analysis and AMF-compliant document generation into a single encrypted workspace. The one design principle is centered around accountability, therefore AI proposes, screen controls and the advisor confirms. For instance, the AI pre-fills suitability assessments, then suggests portfolio allocations and drafts justification narratives. Well, there is always the risk that it becomes a click-factory, no interface can force attention. What the design does is make every confirm a recorded decision with the CIF’s name on it so the accountability is not diluted by speed, it lands on whoever clicked. This is also the human-oversight posture the EU AI Act expects of AI in consequential decisions, built into the workflow rather than added as a checkbox.
The assistant comes as personas and they work in both directions. Default personas cover the standing needs (financial analyst, compliance expert, legal advisor) and the CIF can define their own. They give second opinions on strategy without owning it and they watch the CIF’s own work too: a persona raises an alert when a draft drifts toward non-compliance, away from the client’s risk profile, or past a threshold the CIF has set. For a solo practice, that is the second pair of eyes the advisor cannot hire.
Design decisions
The four calls that shaped the architecture.
No client data reaches an external API without anonymization. Every user message passes through a two-layer detection pipeline before reaching the LLM. Layer one: multilingual NER (distilbert-multilingual-cased-ner-hrl, covering 10 EU languages). It catches names, organizations and locations. The second layer is regex patterns which catch IBAN, NIR (French social security), email, phone, postal codes and dates of birth. Detected entities are replaced with consistent global tokens ([PERSON_1], [PORTFOLIO_1]) via a local registry that persists across the session. The responses are de-anonymized client-side after return. The audit trail records both the anonymized prompt and the restored output.
GDPR erasure and AMF retention pull in opposite directions, so the data model splits. Client data separates into non-PII (MiFID profile, risk tolerance, investment objectives) and client PII (names, contact, SSN), inside one encrypted database (SQLCipher). Retained records only reference clients through anonymized tokens so the token-to-PII mapping lives in its own registry. An erasure request is handled at the registry level: whatever falls outside AMF’s retention scope is deleted outright, what retention covers is kept on that legal ground, and when the 10 years run out, deleting the mapping is what makes the retained trail truly anonymous.
Suitability is decomposed into structured scoring and grounded in actual fund data. Adequacy assessment covers seven dimensions (investor type, knowledge level, risk tolerance, loss capacity, investment horizon, objectives, sustainability preferences). Each is scored pass/fail/partial against the fund’s EMT target-market data. The AI’s compliance narratives are grounded in that scoring and in the underlying fund data and every generated document records its generation context: timestamp, data snapshot, model version, who reviewed and approved. AI-generated content stays visually distinct from CIF-edited content.
The deliberation is part of the record, not just the outcome. Every AI conversation is a persistent thread that can fork. Branches are preserved and dated, and the trail feeds the final recommendation: what was explored, which personas weighed in, what was set aside. This is not best-execution evidence; it is suitability evidence, proof that the recommendation followed from the client’s profile and needs, with the alternatives considered on the record, which is what the AMF expects an advisor to be able to show. The “Fork as branch” control in the proposal screen above is this decision surfacing in the interface.
What this validates
AI can speed up the paperwork without owning the advice.
CIFs will use AI if client data is protected before it leaves the machine, if suitability is structured enough to be challenged and if every generated document is bundled with the audit trail.
The important part is how you make everything work together. Anonymization makes external inference usable and structured MiFID scoring gives it the context. The encrypted local archive makes the record inspectable without putting a SaaS vendor and its processor chain between the advisor and their client files. And conversation branches give the recommendation a trail (alternatives considered, rejected) which is tied back to the final advice. In the same way a requirement would be tied to its final test case in product management.
That is the product test Socle passed. It’s not full production readiness yet but it’s a workflow where AI can speed up the regulated work while the advisor remains the person making, reviewing and owning the decision.
Limits
What stands between this prototype and production.
Socle needs to ship as a standalone local application so that installation and execution are one step rather than a developer build. Local-first packaging creates its own obligation though. The CIF becomes accountable for backing up their data and rolling it back when something goes wrong, and the current system does not handle that at the moment. Backup and rollback are the last step before this could responsibly be put in an advisor’s hands.
The second gap is the inference route. By default Socle runs through the Claude Code SDK rather than the API, which keeps costs near zero. There are fallback routes to the Claude API and a standard interface for plugging in any LLM, but the default path inherits every behavior change in the SDK, message streaming being a recent example.
Socle is one half of a pair. The RWA allocation gateway prototypes how tokenized assets reach retail portfolios; Socle is the regulatory back office of the advisor doing the allocating. Same workflow, seen from both ends.