The research behind the architecture.
MadeForPrivacy grew out of hands-on practice – but the principles behind it are not based on gut feeling. This page lists the studies that explain why AI in business so often fails economically, the papers behind the architecture, and the MFP mechanism that builds on each of them.
How to read this page. The papers cited examine general methods with their own models and benchmarks. Their results are those of the respective study or survey – not measured MadeForPrivacy figures, and no promise of savings or revenue. We cite them because they explain why the architecture is built the way it is. Where MFP implements a principle only partially or differently, we say so.
Business value
Many use AI, few see a return – and the reasons are well known.
Three large studies come to a similar conclusion: AI has arrived in companies, but for most of them a measurable economic effect has not. The causes rarely lie in the model, but in integration, processes and operations – and in the fact that hardly anyone knows what a task costs with AI and what it saves. The figures describe the market; they are not a forecast for MadeForPrivacy.
The GenAI Divide: State of AI in Business 2025
Challapally, Pease, Raskar, Chari · MIT NANDA, July 2025 · preliminary report, not peer-reviewed
The report is based on more than 300 publicly documented AI initiatives, interviews with 52 organizations and a survey of 153 executives (January to June 2025). The authors report that 95% of the organizations studied have so far achieved no measurable financial return from their GenAI initiatives – assessed roughly six months after the pilot. This is not a technical failure: many tools work but change nothing that shows up in the P&L. The authors name a learning gap as the main cause – systems that don't fit into existing workflows, retain no context and don't improve. Successful companies demand process-specific customization and measure business outcomes rather than benchmarks; the authors see the clearest returns in the back office. Context: The report is preliminary, by its own account not representative, and covers a short period. It does not support the widely quoted claim that "95% of all AI projects fail"; individual rates in the report refer to different populations.
- An agent is a process, not a chat window. Incoming invoices, incoming mail, order processing: the agent processes the mailbox or file share you connect, and its tools write the result via API, SQL, email or Microsoft 365 to wherever the process continues. That is the workflow integration the report finds missing in most tools.
- Measured, not guessed. The report criticizes the lack of measurable returns. MFP at least makes the cost side precise: every run is listed in the tracker with steps, tokens and cost down to the cent – per transaction, per agent, over time. What a processed document or an answered email cost is a number, not a guess. The customer compares this with their previous processing costs; MFP supplies the numbers.
- Context from your company. Knowledge supplies information from file shares and Handbooks with source citations, the briefcase carries results from step to step, and Neva remembers what matters to each person. To be honest: agents don't learn from feedback on their own. They improve when prompts, tools and rules are adjusted – in the client, without code, with the tracker showing whether the change made a difference.
- Back office first. The ready-made modules start exactly where the report sees the clearest returns: processing of invoices, orders and delivery notes – many similar transactions, clear rules, measurable effort.
29th Global CEO Survey: Leading through uncertainty in the age of AI
PwC · 2026 · survey of 4,454 CEOs in 95 countries and territories, September to November 2025
56% of the CEOs surveyed say that AI has so far brought their company neither lower costs nor higher revenue. 30% report higher revenue, 26% lower costs – only 12% both. According to PwC, the companies pulling ahead are those that have scaled AI on solid foundations. The study thus provides a newer and much larger data set on why AI investments often don't yet deliver a measurable advantage. Context: These are CEOs' self-assessments, not measured financial figures.
- With MFP, costs are low from day one. It runs as a low-maintenance Docker stack on your own infrastructure or in your own cloud, the license is a predictable monthly fee per server and user, and basic support with updates and ticket support is included in the server price. No project with a six-figure upfront investment, but one process at a time.
- AI costs stay low because the pipeline controls the flow. The model is only called for the step that needs it, receives only the context required for it, and simple steps run on small or local models. Token costs are billed directly by the AI provider, with no MFP markup. Many tools, by contrast, let a large model decide in loops – and every detour costs tokens.
- If 56% see no cost benefit, what's usually missing is the math. With MFP, every process has a price tag: cost per run down to the cent, totaled per agent and month. So for each individual process you can say what it costs and whether it pays off compared with manual processing – before rolling it out to other departments.
- Foundations for scaling. Permissions via AD groups, data zones per agent, tool and AI service, new agents in the client without code: the second and the tenth process need no new infrastructure. That is the difference between pilot and production that PwC sees among the leaders. MFP affects revenue only indirectly, through faster responses and shorter turnaround times – we don't claim that as an effect; customers measure it themselves.
Where's the Value in AI?
Boston Consulting Group · October 2024 · survey of 1,000 executives across more than 20 industries and 59 countries
According to BCG, 74% of companies have not yet developed the capabilities needed to deploy AI at scale and achieve tangible value; only 26% get beyond proofs of concept, and 4% are considered leaders. BCG puts around 70% of the obstacles down to people and processes, 20% to technology and only about 10% to algorithms. Leaders use AI in core processes rather than only in support functions and focus on fewer use cases, which they then scale consistently. Context: a survey of executives, not a measurement of individual projects.
- Fewer use cases, but end to end. A module is a core process with setup, connection to your ERP, accounting or ticket system, and support – not yet another pilot alongside three others. What demonstrably works and pays off in the tracker gets expanded.
- 70% people and processes: no platform can do this work for you. We clarify data flows, responsibilities and approvals before the first agent, and a dedicated contact person supports rollout and operation. MFP makes this work manageable: the workflow is defined as a pipeline in the configuration, every approval is a separate step, every change is traceable in the tracker.
- 10% algorithms: no model arms race. In MFP, models are interchangeable services per data zone – Azure, local models, other providers. A better or cheaper model is configured per step, and the process stays the same. The investment goes into the process, not the model.
- Scaling without additional per-user operating costs. The same agent runs for every authorized group; the tracker shows what it costs per month for each agent. Core process rather than side function means, with MFP: the agent handles the transaction instead of just advising on it.
Pipelines instead of prompts
Breaking complex tasks into small, verifiable steps.
An MFP agent is not one long instruction to a model but a chain of tools: read the document, extract fields, check, pass on. Research has shown repeatedly that this kind of decomposition works better than a single large prompt.
Decomposed Prompting
Khot, Trivedi, Finlayson, Fu, Richardson, Clark, Sabharwal · ICLR 2023
The paper introduces a "decomposer" that breaks a task into subtasks, each solved by specialized handlers – separate prompts, other models or ordinary program functions. Because each handler stands on its own, it can be improved, replaced or reused recursively. On multi-step tasks (including symbolic manipulation and multi-hop questions), the approach clearly outperformed classic chain-of-thought prompting in the study.
- Every agent is a pipeline of tools (
document-processor,llm-extract,llm-classify,transformer,pdf-generator…), each step with its own prompt, its own model and its own data zone. - Deterministic steps (regex, filters, database, API) handle everything that doesn't need a model – exactly the paper's "symbolic handlers".
- Sub-agents via the
agenttool: a step can call another agent and continue working with its result.
Least-to-Most Prompting
Zhou, Schärli, Hou, Wei, Scales, Wang, Schuurmans, Cui, Bousquet, Le, Chi · ICLR 2023
Hard problems are first broken down into simpler subproblems, which are then solved in sequence, with each answer feeding into the next step. In the study, this let models generalize from easy examples to much harder tasks on which chain-of-thought prompting failed.
- Pipeline steps build on each other: the briefcase carries the results of each step (as typed items) into the next.
- Order and dependencies are configured, not left to the model – which makes runs reproducible and visible in the tracker.
Plan-and-Solve Prompting
Wang, Wei, Li, Zhang, Chen, Chen, Xu, Wang · ACL 2023
Instead of diving straight in, the model first draws up a plan of subtasks and then works through it. The authors show that separating planning from execution reduces typical zero-shot chain-of-thought errors – above all, skipped steps and calculation or comprehension errors.
- In MFP, the plan lives in the configuration: what an agent does is defined and documented in advance as a sequence of steps – no model has to reinvent it every time.
- Neva plans on one level only: she picks the right agent for a task (
llm-classify), and execution remains the fixed pipeline.
Toolformer: Language Models Can Teach Themselves to Use Tools
Schick, Dwivedi-Yu, Dessì, Raileanu, Lomeli, Hambro, Zettlemoyer, Cancedda, Scialom · NeurIPS 2023
The paper shows that language models can learn to call external tools at the right points – calculator, search, calendar, translation – and incorporate the results into their answers. In the study, a comparatively small model trained this way matched the performance of much larger models on tasks that require facts or calculation. Key takeaway: tools make up for what a model cannot reliably recall from memory.
- In MFP, tools are first-class building blocks: API, SQL, file, mail and Knowledge tools supply the facts, and the model writes or classifies – it shouldn't have to "know" anything a tool can look up.
- Unlike Toolformer, it is not the model that decides when to call a tool – the pipeline defines it. The effect is the same (facts from systems instead of from the model), but the flow stays deterministic and traceable.
Targeted context
Not “everything into the prompt”, but what’s relevant.
Large context windows make it tempting to send entire documents and conversation histories along. That doesn’t just cost tokens – it demonstrably makes answers worse.
Lost in the Middle: How Language Models Use Long Contexts
Liu, Lin, Hewitt, Paranjape, Bevilacqua, Petroni, Liang · Transactions of the ACL 2024
The authors systematically vary where the relevant information appears in the context. Result: models reliably use information at the beginning and the end, but accuracy drops sharply in the middle – a U-shaped curve that also appears in models explicitly designed for long contexts. So more context is not automatically better; what matters is that the relevant information gets there at all, and as prominently as possible.
llm-extractreturns the IDs of the items it used along with the result;item-filterpasses only those items on to the next step – the prompt contains what the step needs, not the whole briefcase.- Knowledge returns the top-k passages with source citations instead of entire documents; the conversation history is limited to a fixed number of turns per agent.
- Visible in the tracker: tokens per step show what was actually sent to the model.
Connecting company knowledge
Knowledge from your documents – without changing the models.
Company knowledge doesn’t belong in the model but in a searchable store, from which the relevant excerpt is retrieved for each request. This is well researched – and it’s why MFP doesn’t train a model on your data.
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
Lewis, Perez, Piktus, Petroni, Karpukhin, Goyal, Küttler, Lewis, Yih, Rocktäschel, Riedel, Kiela · NeurIPS 2020
The paper combines a language model with a retriever over an external document collection: relevant passages are retrieved for each query and passed to the model. In the study, the answers were more specific and more factual than with purely parametric knowledge – and the knowledge can be updated by replacing the index instead of retraining the model.
- Knowledge in MFP follows exactly this pattern: file shares, Handbooks and mailboxes are indexed in datasets;
knowledge-retrievalretrieves the relevant passages for a question and passes them into the step with source citations. - Updating means ingesting new documents (
knowledge-ingestion) – no training, no change to the model.
REPLUG: Retrieval-Augmented Black-Box Language Models
Shi, Min, Yasunaga, Seo, James, Lewis, Zettlemoyer, Yih · NAACL 2024
REPLUG treats the language model as a black box: the retriever simply prepends the retrieved documents to the input, and the model itself stays untouched. The authors show that even large models that cannot be modified benefit from external knowledge this way – and that the retriever can be improved using feedback from the model without touching its weights.
- MFP uses models as interchangeable black boxes – Azure, local models, other providers – and places retrieval (RAGFlow) in front of them as a separate service. The same knowledge base works with any model in the relevant data zone.
- Access to datasets is tied to AD groups: anyone who isn't allowed to read a document can't get it through the AI either.
The right model for each step
Small models for simple steps, large ones only where they add value.
Not every step needs the most powerful model. Research on model selection and cascades shows how much cost is hidden in undifferentiated calls – MFP applies the principle through configuration, not through a learned router.
Hybrid LLM: Cost-Efficient and Quality-Aware Query Routing
Ding, Mazumder, Fu, Zhao, Zhu, Zeng, Rühle, Menache · ICLR 2024
A router estimates in advance how difficult a request is and sends simple requests to a small model and hard ones to a large model. In the authors' experiments, this avoided a substantial share of calls to the large model without any measurable loss in answer quality – the threshold can be adjusted via a quality parameter.
- In MFP, the assignment is configured per pipeline step: every step has its own list of permitted AI services (
ai_service_ids). Classification and filtering run on small models, complex extraction on large ones. - Within a step, MFP distributes requests across equivalent services by priority and load balancing. There is no learned router based on request difficulty – the operator makes that decision, traceably in the tracker.
FrugalGPT: How to Use Large Language Models While Reducing Cost and Improving Performance
Chen, Zaharia, Zou · Transactions on Machine Learning Research 2024 (arXiv 2023)
The paper sets out three levers against LLM costs: shortening and batching prompts, caching answers or using smaller models, and cascades in which a low-cost model answers first and the request is escalated only if reliability is low. On their benchmarks, the authors matched the quality of the most expensive model with such combinations at a fraction of the cost.
- MFP implements the first two levers: concise, step-specific prompts with only the items needed, and smaller models for simple steps. Cascades with automatic escalation are not available.
- No flying blind on costs: every call is recorded with its tokens at the configured rates (cost per run in the tracker), so you can see which step is worth it.
Verify, don’t trust
A second step checks what the first one delivered.
Models make mistakes – and they are better at finding their own mistakes when checking is a separate step with its own question. That’s why MFP has verification as a dedicated tool.
Chain-of-Verification Reduces Hallucination in Large Language Models
Dhuliawala, Komeili, Xu, Raileanu, Li, Celikyilmaz, Weston · Findings of ACL 2024
The model first writes a draft, then plans verification questions about the claims it contains, answers them independently of the draft and uses the answers to produce the final response. The separation is what matters: when the verification questions are answered without looking at the draft, the model repeats its errors less often. In the study, the number of fabricated statements dropped significantly across several task types.
extraction-verificationis a separate, deterministic pipeline step: every extracted value is matched against the text of the source document (fuzzy match) and assigned a confidence score – independently of the model that did the extraction. Anything that isn't in the document stands out.- The confidence scores are attached to the items as values; downstream steps (e.g.
item-filter) route uncertain cases to manual approval instead of waving them through.
Self-Refine: Iterative Refinement with Self-Feedback
Madaan, Tandon, Gupta, Hallinan, Gao, Wiegreffe, Alon, Dziri, Prabhumoye, Yang, Gupta, Majumder, Hermann, Welleck, Yazdanbakhsh, Clark · NeurIPS 2023
The same model generates an answer, critiques it in a second call and revises it in a third – without any training, just through separate roles in separate calls. Across seven tasks, both human raters and automatic metrics clearly preferred the revised results to the first draft.
- In MFP, generating and evaluating are separate steps: an
llm-classifyorllm-extractstep can assess the output of a previous step with its own prompt and useexecution_conditionsto decide whether it gets reworked or passed on. - Iterations are configured, not an endless loop: the pipeline defines how many refinement passes there are – and every pass appears in the tracker with tokens and cost.
Why data zones and fixed tools
The risks are well researched – the architecture acts on them.
Two findings from security research shape MFP: models can leak training data, and agents with tools can be hijacked through third-party content. Both are the reason for technical safeguards – they are not proof that MFP is immune to these attacks.
Extracting Training Data from Large Language Models
Carlini, Tramèr, Wallace, Jagielski, Herbert-Voss, Lee, Roberts, Brown, Song, Erlingsson, Oprea, Raffel · USENIX Security 2021
The authors extracted hundreds of verbatim memorized training sequences from GPT-2 – including names, addresses and contact details of real people – even though each of them appeared only once in the training data. Larger models were more vulnerable. Follow-up work by Nasr et al. (ICLR 2025) shows that even production-grade, aligned chat models can be made to output training data.
- That's why MFP does not train any model on your data – knowledge is supplied via retrieval (see above), not trained into the model.
- Data zones define technically which data may go to which service in the first place: Local only · GDPR-compliant · Unprotected. Agents, tools and AI services each carry a zone, and MFP checks this at every step. The "GDPR-compliant" zone only includes services that do not use inputs for training.
Not What You've Signed Up For: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection
Greshake, Abdelnabi, Mishra, Endres, Holz, Fritz · AISec @ CCS 2023
The paper describes indirect prompt injection: an attacker hides instructions in data that the system reads later – web pages, emails, documents. As soon as an LLM processes this content, it can be manipulated into leaking data, altering answers or taking unwanted actions. InjecAgent (Zhan et al., Findings of ACL 2024) measures this for agents with tools: in the benchmark, even strong models could be tricked into harmful actions via manipulated tool outputs in a significant share of cases.
- MFP agents don't choose their own tools: the pipeline defines which tools a step may use. An instruction hidden in an incoming email cannot trigger an extra database or API call, because that step doesn't exist.
- External content is data in the briefcase, not instructions: it is processed as typed items, outputs are validated against schemas, and actions with external effects (sending an email, writing to an API) are separate steps that require approval.
- Permissions are tied to groups and zones, not to the model: an agent can only reach what its group and zone allow – and every run is traceable in the tracker.
What’s deliberately not included
What we don’t claim.
No learned router
The operator assigns models per step. Approaches such as RouteLLM or LLM cascades (FrugalGPT) are current research, not MFP features.
No open-ended agent loops
MFP deliberately does not use ReAct-style reason-and-act loops in which the model picks its own tools – for the sake of traceability and a smaller attack surface.
No constrained decoding
Structured outputs are produced through schema prompts and validation, not by interfering with the model's token generation.
No proof of protection
Data zones and fixed tools are product controls. They replace neither a data protection assessment nor a security audit of your installation.
No guarantee of returns
MIT, PwC and BCG describe why AI initiatives fail economically. These figures don't tell you how much an agent will save in your company – only your own process in the tracker can show that.
Not a self-learning system
Agents don't learn automatically from feedback. Improvement is configuration work on prompts, tools and rules – transparent rather than creeping.
Live demo
Better to see it in action than read about it?
In the live demo, we show you pipelines, the tracker and data zones using your own use case.