← Roberto D'Aleo

Three chapters, in English

From La scala senza attrito — The Frictionless Climb — a book on AI agents applied to a real B2B distribution business, published in Italian in October 2026. These three chapters are translated in full, unabridged.

Chapter 3

When One More Person Isn't Enough

Original: Capitolo 3, «Quando non basta la persona in più»

The day comes when you decide to hire. You recognize it by how you get there: you've been underwater for months, overtime isn't enough anymore, and at some point you say the sentence to yourself — we need one more person. You approve the position, the search begins, and just making the decision feels like coming up for air. That relief is legitimate, because the diagnosis is correct: there's more work than the hands you have. The problem isn't the diagnosis. It's assuming that adding hands is the only cure. That cure works — I've seen it work many times — but it costs far more than the payslip says, and part of the bill comes due exactly when you're most fragile.

The salary, in fact, is the small line item. Around that person sit the employer contributions, the desk, the tools, the training — and above all, other people's time. Someone has to select them, someone has to teach them how things work here, someone has to correct their first mistakes and answer their first questions. And that someone is almost always your best person — the one already under pressure, because they're the only one who knows the job well enough to pass it on. For a few months, then, the new hire isn't just unproductive yet: they're draining capacity from someone who was productive. You pay twice, and you pay at the worst possible moment — the moment you hired precisely because you couldn't keep up.

Time is the variable almost nobody puts in the calculation. Between the day you open a search and the day that person works independently, months pass: weeks to find them, weeks of notice, more weeks before they're truly productive. The market, meanwhile, doesn't wait. The peak that brought you to your knees this year may have already moved on; the client you served badly may already be gone. Hiring answers today's problem with a solution that arrives in six months, and those six months are part of the cost, even though they never appear as a line anywhere.

And there's the risk. Every hire is a bet: on the person, on the fit with the team, on whether it holds over time. Sometimes the bet goes badly, and you find out after you've already spent months of training and salary. Sometimes it goes well, but the person — trained and now valuable — leaves after two years, and you start over. There's an even subtler risk, one that has nothing to do with the person's competence and everything to do with the balance they step into. Every newcomer is a disturbance in the web of relationships that, silently, holds the place together: who talks to whom, who trusts whom, who covers for whom on a bad day. It's a balance written down nowhere, and slotting a new person into it shifts it in ways you can't predict — sometimes for the better, sometimes not. You don't know beforehand. You find out after. I'm not saying you shouldn't hire. I'm saying hiring isn't the neutral, linear lever we imagine. It's a step, and steps are climbed one at a time, each with its own effort and its own risk.

There's another effect that only shows up once headcount grows, and it works against you quietly: more people doesn't just mean more hands, it means more coordination. Every additional person adds handoffs, alignment meetings, and the need to write procedures so everyone stays on the same page. A share of the capacity you just bought gets eaten by the sheer fact that there are now more people who have to talk to each other and check each other's work. It's why, past a certain threshold, adding people to a process can actually slow it down instead of speeding it up — and the quality you were trying to protect dilutes across the handoffs, because work that used to live in one person's head now crosses three desks, and at each desk it can stumble. This isn't an argument against people. It's an argument against the idea that adding them fixes a problem that is structural, not a matter of headcount. The bigger you get, the more you spend just to stay coordinated — and that spend never shows up as a line item, but it's as real as any other.

One story, among many, says it better than any argument. At one of the companies I worked for, we fell behind on purchase orders at one point — even though the team included a colleague who was excellent and completely dedicated, who knew that job better than anyone (a nod to her, wherever she is). The decision seemed obvious: one more person to work alongside her. In six months, three people came and went, one after another. Each had her own snag — an attitude, a slowness, a way of working that just didn't click — but the simplest truth was another one: none of them was her. In the meantime we'd burned precious hours — her hours — selecting them, training them, correcting them, only to end up, six months later, exactly where we'd started, just more tired and with half a year lost along the way. It wasn't bad luck. It was the mechanism working exactly as it does: we'd answered a structural problem by adding hands, and hands alone couldn't untangle it.

This is the structural point, the one that turns a management headache into a model problem. Hiring makes the organization grow in steps, not continuously. Every major jump in revenue eventually forces a jump in structure, and between one step and the next you live in the same dilemma: either you grow badly, losing quality while the structure struggles to keep up, or you stop, or you make the jump and take on a new fixed cost before the volume justifies it. In that transition the margin compresses, because the cost lands immediately and the revenue that repays it arrives later — and if you read the jump wrong, you're left with the cost and without the volume. Growth, which should be one continuous thing, becomes a staircase of awkward steps.

The last point explains why one more person, on its own, isn't enough. Most of the work you hire for isn't high-level judgment, but it isn't mechanical either: it's work that repeats without ever being quite the same twice, and it grows in exact proportion to volume — chasing payments, entering orders, preparing quotes, checking stock, reconciling. If your only answer to that load is always more people, your cost base grows at the same speed as revenue, and you never gain leverage: every extra euro of revenue drags its own extra euro of operating cost behind it. You're buying capacity for work that, looked at closely, doesn't need a person — it needs a different way of being done. I hold onto this distinction because it's the hinge of the whole book: hiring for judgment — for the salesperson who opens markets, for whoever leads and decides — is one thing. Hiring to plug a repetitive workload that keeps multiplying on its own is another.

Seen this way, hiring stops being the only possible answer and goes back to being worth exactly what it's worth: right for the functions that require judgment and relationships. For everything else — for the repetitive load that today forces you up one step after another — there's a third way, different from both working harder and hiring more. What that is, I build over the rest of this book, but the promise is precise: absorb the repetitive work without adding a person at every jump in volume, and turn the staircase into a continuous climb.

To anyone looking at the company from outside — to whoever allocates capital — all of this says something they already know very well. Growth through successive hires is growth without operating leverage: cost follows revenue step by step, and the margin stays nailed to where it is. The real value, the value a buyer pays for willingly, sits in companies able to grow revenue without growing headcount at the same pace, because it's in that gap that margin expands over the holding period. The question, then, stops being how many people to hire and becomes how to scale without climbing a step every time. It's actually an old question, and a technological answer was already tried decades ago, with the promise of letting us do more with the same structure. That answer was called the ERP system — and understanding what it kept of that promise, and where it stopped short, is where we pick up next.

Chapter 15

No Longer Settling for the Bare Minimum

Original: Capitolo 15, «Smettere di fare il minimo indispensabile»

A CFO always wants to do more. More controls, deeper analysis, better-built reports — not out of perfectionism, but because they know exactly which corners of the business they're watching too little, and that sooner or later that's where the surprise will come from. The problem is that at some point the sheer volume of work makes doing the bare minimum in certain areas inevitable. It isn't an oversight. It's a conscious surrender, made every year at the same moment, on the same things, and its distinctive feature is that it leaves no trace anywhere. Nobody writes "the analysis we didn't do" into the accounts. You see it much later, when the client nobody reassessed stops paying, or when the variance nobody caught in time has become the whole year.

The example I know best is financial planning. You end up doing it in a spreadsheet, or with one of the fashionable software packages, and either way you carry home the same limitation: a discrete approach that accounts for a handful of variables and a handful of scenarios. You build the pessimistic case, the expected case, the optimistic case, line them up in three columns, and it looks like a forecast. In reality it's three opinions in a row. What that model doesn't tell you — and what you actually need — is how likely the scenario you just described really is. If the expected case has a seventy percent chance of happening, the conversation with the bank is one thing; if it has twenty percent, it's another. Three columns on a spreadsheet will never tell you that. The spreadsheet can't even ask the question.

That's the point where I stopped waiting for the market to sell me the answer and built it myself. Describing the result I wanted to a model in plain language — what's now called vibe coding1 — let me put together a cash-forecasting tool that considers far more variables than a spreadsheet ever could. A tool that, instead of producing a single line, runs a Monte Carlo simulation.2 It replays the same future thousands of times, changing collection delays, bad debt, and seasonality within plausible ranges each time, and counts how often each outcome occurs. What comes out isn't a number — it's a distribution. The practical difference is enormous: you no longer say cash in March will be a certain figure; you say that in ninety percent of the runs it stays above the threshold. You can even say which week concentrates the risk of running tight. A CFO who brings that sentence to the owners or to a bank isn't offering an opinion — they're handing over a measurement.

That tool works for me for a less obvious reason too: it's mine. Off-the-shelf planning software is customizable at the margins — the color of the chart, the layout of the report — while the things that actually matter, which variables exist and how they behave, were decided by the vendor for all of its customers at once. Building it for a single company means the customization reaches the fundamentals: non-recourse factoring treated as an outright sale because that's how I choose to think of it, bank drafts with their own bad-debt behavior and the advance on the credit line, immutable archived data snapshots instead of a file someone re-saved. It's the difference between a model that looks like your company and one that looks like an average company that doesn't exist.

An in-house tool has another advantage that matters even more: you can connect it to everything else. The quality of a cash forecast depends almost entirely on one thing — knowing how your customers actually pay — and that knowledge doesn't live in the treasury spreadsheet, it lives in the system that manages credit. Bussola Crediti, the application I described in the chapter on credit, has already measured that data: each customer's habitual delay, how reliably they keep their payment promises, their up-to-date risk score. Connecting it to the forecasting tool means I'm not inventing the simulation's parameters or smearing them across a company average — I'm pulling them customer by customer, from whoever watches them every day. It's the idea of connected AI agents applied to my own two tools: one knows how customers pay, the other knows what that means for cash, and together they say something neither could say alone.

The same connection opens up territory that mid-sized companies almost always manage poorly: currency hedging. Anyone who buys or sells in a currency other than their own carries an exposure. The real question isn't whether to hedge, it's exactly what to hedge and with which instrument — an option, a flexible forward, a repo each have different costs and make sense at different moments. It depends on how exchange rates are moving and how much you're willing to pay to remove the uncertainty. It's an assessment that should be redone continuously, and precisely for that reason it ends up being done by rule of thumb — hedging everything or hedging nothing. An AI agent can keep it alive: which flows are genuinely exposed and on what timeline, what each form of hedge costs today, which one makes sense given the currency outlook. And it can take the step that always gets forgotten by hand — closing the flexible forward at the exact moment the payment arrives, because the credit system is the one telling it so. At this point the two tools aren't just exchanging data anymore: one triggers an action in the other.

Then there are the tasks nobody ever mentions at conferences, and that eat up either time or risk. Anyone who exports knows one of them: chasing proof of delivery. To avoid charging VAT on a cross-border sale, you have to be able to prove the goods actually left the country — and that proof isn't yours, it belongs to the freight forwarder, on their portal, in their format, and the portals are different for every forwarder. Doing it by hand, invoice by invoice, is such thankless work that in practice it gets done on a sample basis, or in a rush the day the audit arrives. An AI agent that scans foreign invoices, pulls the proof of delivery from the forwarder's portal, downloads it, and files it against the right invoice turns a latent tax risk into a complete archive, without costing anyone an hour.

Credit comes back here too, but from a different angle than in chapter thirteen, because seen from finance the problem isn't so much assessing it as knowing when the assessment has gone stale. An AI agent can pull financial statements from the chamber of commerce through its APIs, and that alone removes a tedious routine. In a more advanced version it takes a far more interesting step: it asks itself whether that customer's rating and credit line are still reliable given how they've actually been behaving — and it only goes and fetches new financials when the answer is no. It stops being a periodic collection applied equally to everyone and becomes selective surveillance, switching on exactly where it's needed. And that's why the real-time credit check on a quote, which I described in the chapter on credit, actually works: when the quote asks how much credit is still available, the number that comes back isn't a two-year-old snapshot — it's fresh enough to decide on.

Management control, though, is where I see the biggest leap, and it comes down to two things together: granularity and timing. On granularity, the analytical power of language models allows a level of detail that used to be unsustainable — not margin by product family, but margin by customer, by line, by job, without anyone having to build the table. On timing, which matters even more, you can finally work during the operation instead of after it. Management control was born as a backward-looking discipline: you close the month, consolidate, analyze, and halfway through the following month you discover that job had a lower margin than planned. Its usefulness decays by the day, because there's nothing left to do about something that happened six weeks ago. An AI agent with immediate access to the data flips the sequence. A variance against forecast is no longer a chapter in the monthly pack — it's an alert that arrives while it's happening, while there's still time to renegotiate a price, stop a purchase, call a customer. Control stops being a report and goes back to being what it should be: a lever.

This is where the question of where that data lives and how it's kept together would open up. I'll come back to what to keep further on; where to keep it physically I won't get into, because it's a technical choice that changes with the tools and would date this book faster than anything else in it.

What's left, lined up, is a change in the nature of the job. The CFO stops spending most of their time building the numbers and goes back to spending it deciding with the numbers — the only part of the job they were actually hired for. The corners left at the bare minimum stop existing, because covering them no longer costs hours that don't exist. For an investor, the translation is even more direct: a cash forecast with a probability attached instead of three columns of opinion, a variance that arrives in time to be corrected within the quarter instead of explained a year later, and a finance function that carries more volume without growing. It's the kind of control a fund demands in its portfolio companies, and almost never finds already installed in a small one.

Two worlds remain outside this chapter, for now, more alike than they seem, because both live on evidence that has to be produced and kept. The one we just saw, proof of delivery, and the much larger one of quality and documentation, where a missing form isn't an annoyance — it's an audit finding.

1 Vibe coding is the way of programming in which you describe the result you want in plain language to an AI model, and it writes the code. It's a way of working, not a product: for someone who knows their trade but isn't a programmer, it's the door that made it possible to build tools to measure instead of buying standard ones.

2 The Monte Carlo method simulates the same phenomenon many times, randomly varying the uncertain quantities within plausible ranges, then looking at the distribution of the results. Applied to cash: instead of computing a single forecast using expected values for delays, bad debt, and seasonality, you compute thousands of them with values drawn differently each time, and the result isn't a number but a probability — for example, the percentage of simulations in which the balance drops below a given threshold.

Chapter 18

The Map Is Not For Sale

Original: Capitolo 18, «La mappa non è in vendita»

Tomorrow morning you can buy an AI agent that manages collections reminders. So can your competitor, probably from the same vendor at the same price, and within two years everyone will have one and nobody will think twice about it — the way nobody today brags about having email. What you can't buy, and what no vendor can sell you because it isn't theirs to sell, is the knowledge that agent has to work with: which of your customers really pay on time and which just promise to, which supplier states four weeks and actually takes six, which product line nobody touches because three years ago a bad delivery shut down a customer's production line. In the chapter on contextual memory I called all of this the knowledge graph, and left one sentence hanging: AI agents will become a commodity, the map won't. This chapter is where that sentence gets paid off.

Take the first example, which looks the most trivial. Anyone who has never managed credit thinks a customer either pays or doesn't. Anyone who has managed it knows customers promise based on their own cash forecast: if the money they were expecting doesn't come in, the payment they promised you doesn't go out either — and it isn't bad faith, it's arithmetic. From this follows something no balance sheet will ever tell you: promises aren't all worth the same, and for some customers a promise is as good as a wire transfer, while for others it's just a description of an intention. In my line of work, the measure of how much this matters is a detail I remember well: roughly a third of collection calls open with "they promised me that." That knowledge lives in no field of any system. It lives in the head of whoever has been making those calls for years, and the day that person changes jobs, it leaves with them.

The first reason context holds up is that knowledge like this has no price list. You can buy a language model, an ERP system, a database of financial statements, even the advice of someone who's done the same thing in ten companies like yours. You cannot buy ten years of promises kept and broken, because nobody owns them in a form they could sell you. And stealing them wouldn't be enough either: if your competitor walked off with your entire graph, they'd have the history of your customers, not theirs — an extremely detailed map of a territory they don't operate in. It's the lesson of the Fremont plant from the previous chapter, moved from how work gets done to the data itself: even handed over outright, that advantage doesn't transfer.

The second reason is that context accumulates, and in accumulating, it pulls away. Every exception resolved leaves a trace, every promise kept or broken adds a line to a customer's real reputation, every delay shifts a supplier's measured reliability by a fraction. This is where the time I discussed at the end of the previous chapter takes concrete shape: whoever starts today doesn't need to buy something you have — they need to live through the same years you've already lived through, while you keep accumulating more. The advantage isn't that you're ahead. It's that the gap widens on its own.

I'd be dishonest, though, if I stopped the argument here, because a moat1 can run dry. Context rots if nobody keeps it alive: records get duplicated, information ages, the people who knew retire and take with them what was never written down anywhere. And it doesn't transfer: open a new product line tomorrow, or enter a market you don't know, and your context there is worth zero — you're as much a beginner as anyone else. Anyone who sells you context as a perpetual annuity is selling you a fairy tale.

Of all the ways context gets lost, knowledge walking out the door with people is the most insidious, and it has a name that's sixty years old. Michael Polanyi coined it in 1966 with a phrase that became famous — we know more than we can tell — to describe everything a person knows how to do brilliantly and couldn't explain to anyone. Thirty years later, Ikujiro Nonaka and Hirotaka Takeuchi made converting that tacit knowledge into explicit knowledge the central task of the firm, so it becomes the organization's instead of one person's. The trouble is that conversion has always been brutally expensive. It was done through interviews, manuals, and procedures nobody read and that were out of date the next day — which is why almost nobody ever actually finished it.

So far, though, I've said things a good general manager already knew twenty years ago. What's new — what changes the job, and what makes this chapter different from a strategy chapter out of the nineteen-nineties — is that today the same technology that needs real context is also the first one capable of fixing the underlying data. Until yesterday, data quality was a discipline problem: it depended on people entering, checking, updating, and since those people had other things to do, the data degraded. It was a battle you lost slowly. Now that battle can be fought with the same tools described throughout this book, and that changes the nature of the problem.

The first move is probes on the correctness of information, and it's worth distinguishing them from something that has always existed. Traditional validation checks that a piece of data is well-formed: that a tax ID has the right number of digits, that a date exists on the calendar, that a required field isn't empty. Useful, and completely blind to meaning. What you can do now is check whether a piece of data is plausible, which is an entirely different thing, because plausibility can only be judged with context. Take a customer who for years has bought parts destined for a large aerospace and defense group, and who for the past few months has been ordering material destined for a coffee-machine manufacturer. No field is wrong, no formal rule is broken, and no traditional check will ever flag it. And yet something happened: either the customer has changed, and your read of them is stale — classification, risk, maybe price need revisiting — or there's an error further upstream. Either way, someone needs to know, and nobody ever will by reading twenty thousand order lines. The same logic applies to a question a CFO asks often and almost never in time to matter: why is the margin on this job so high, when the average for that type of business runs much lower? An outsized margin isn't good news — it's a question, and the answer might be a price that was never updated, a cost that was never allocated, or an error that will come back as a customer complaint. A probe asks that question while the job is still open, not nine months later when it's material for a memo.

I have a precise, recent memory of what it costs not to have those probes. In February 2021, an exceptional freeze hit Texas and knocked out power to the largest concentration of petrochemical plants in the world. Between eighty and eighty-five percent of U.S. polyethylene and polypropylene production stopped, several producers declared force majeure,2 and within a few weeks lead times on anything with a significant plastic component started stretching out of proportion, for months. The point isn't that it happened — that was never in our control. The point is when we noticed: only once the delays were already substantial, meaning once deliveries to our own customers had already slipped. And yet both signals had been there for weeks. The first was inside our own walls, in the delivery history, where certain suppliers were each time taking a few days longer than the previous cycle. The second was on the front page of every newspaper in the world, because a storm that blacks out Texas is not a private piece of news. All that was missing was someone to connect the two — and it was nobody's fault that no one did: it would have taken a person reading the international press every day while holding twenty thousand part numbers in their head, knowing for each one how much plastic it contains and where it comes from. That's the job you can now hand to an AI agent.

The second move concerns how data gets in, and it's the one that solves the problem that has killed corporate information systems for thirty years. In the chapter on sales, I described the voice memo recorded in the car that turns, on its own, into an updated customer record; there it looked like a convenience, here it's far more. If feeding context costs time that nobody has, context doesn't get fed — which is why CRMs are full of empty fields. But if the information goes in on its own, because someone said it out loud, because it arrived in an email, because it was inferred from a document, then the map grows as a byproduct of ordinary work instead of as an extra task. And this is where the account opened earlier with Polanyi closes: converting tacit knowledge into the company's knowledge stops requiring a dedicated project, with its interviews and its manuals, and becomes a byproduct of what people already do. The moat stops depending on their goodwill at peak times — which is exactly when goodwill runs out.

The third move is enrichment from the outside: AI agents that fill in what's missing by pulling publicly available information through APIs — financial statements, registry records, news, industry data. And here there's a consequence for an entire industry: it's this book's thesis applied to another sector. Whoever sells information today sells a finished product, built for a human being to read: a document, a report, access to a database through a search screen. Tomorrow the reader is no longer a person, it's an AI agent, and an AI agent doesn't want a document — it wants a continuously queryable, updated stream, with its provenance declared and verifiable, and the ability to be cross-checked against others. Whoever stays wedded to the document will become an undifferentiated commodity bought at the lowest price; whoever transforms will become infrastructure, and will be paid far more for it.

At this point an attentive reader — and an investor is attentive by trade — raises the right objection: if everyone will have these tools, and everyone will be able to clean and enrich their own data, doesn't the moat just get filled in with dirt? The answer is that AI lowers the cost of keeping context clean and fed, not the cost of having lived it. Your competitor can point the same probes at their own history, but it's their history, and if it's thin, the probes will only tell them, faster and more precisely, that they don't know much. The history of your customers is a fact that already happened, and facts that already happened aren't for sale. What changes — and what needs to be said plainly to anyone deciding right now — is that the cost of starting to build that history is no longer prohibitive: which is exactly why waiting, today, costs more than it cost to wait five years ago.

For the owner-operator, the translation is simple: the question to ask isn't which AI agent to buy, it's whether in three years the company will know things about itself that its competitors don't know about themselves. Whoever is evaluating the company for acquisition gets there by a shorter road: price. A company where you can see in the data who really pays, which suppliers hold up, and where the margin leaks is a company with fewer unknowns — and unknowns get priced at a discount in due diligence. There's an effect a fund recognizes immediately: when that knowledge lives in the context instead of in three people's heads, the risk of it walking out with them drops, and a company that doesn't depend on who works there is worth more than one that does. This is the point where the knowledge graph stops being a technical detail explained with effort and becomes a line item in the valuation.

One practical question remains, and it isn't small: where do I get all this raw material now? The answer is less discouraging than it sounds, because most of it is already yours, and you're throwing it away every day without noticing.

1 Moat is the term investors use for a competitive advantage that time doesn't erode and that competitors can't close by spending money. The image is the moat around a castle: it doesn't make the position unconquerable, it makes it expensive to attack.

2 Force majeure is the clause under which a supplier, facing an exceptional event outside its control, is released from its obligation to deliver on the agreed terms without penalty. Once a manufacturer invokes it, confirmed orders lose their date: the goods arrive when they arrive, and the customer has no contractual recourse to demand otherwise.