I will be honest with you: I am equally fascinated and equally worried about where the AI advancements are taking us.

Every week I watch something that feels impossible become normal. Artificial intelligence and agents are aggressively automating parts of my work, and parts of my life. Heck, there are now robots being built to be sold as personal assistants, and that is not really a fantasy anymore. It feels about three to five years away, and maybe that is generous.

So I keep asking the same question. Where is this actually going? For me, for you, for our jobs, our companies, and our everyday life.

There is no shortage of takes on AI. There is a shortage of clear ones.

Most of what reaches you is either hype trying to sell you something, or doom trying to scare you, with a lot of slop in between. There is no clean, concrete answer about where this goes. But once you filter all that out, you can start making some calculated predictions.

And here is the hard part of any paradigm shift: the old way of doing things quietly stops working, and most people keep going as if nothing changed. It is genuinely hard to see the shift while you are standing inside it.

Here is one thing I have already learned from putting AI to work inside real companies. The bottleneck is no longer whether you can build something. Building is becoming dramatically cheaper and faster. The scarce skill is knowing what is worth building in the first place: taste, judgment, and the ability to see what should exist.

That quietly reshapes a lot of jobs. I think we are entering an era where the most valuable people are the ones who can combine creativity, judgment, and execution: who can turn a vague idea into a working thing, and also judge whether it should exist at all. I have started calling this person the creative engineer.

That is the kind of lens I want to build here. Not “AI is coming,” but what specifically changes, and what you can do about it.

So what is nickintheloop?

It is short, sharp takes on the AI Paradigm Shift as it actually unfolds: what is happening, what it means, and what I would do about it. I pull from what I see on my day to day work and from what is moving across the wider world.

I get a useful vantage point for this. I work at Prosus, one of the world’s largest consumer-internet groups, putting frontier AI to work inside products used by millions of people across Latin America, Europe, India, and Asia. That is a front-row view of what is actually working with AI right now, across very different markets.

nickintheloop is for the AI-curious, not just the technical. If you are not in AI but you want to understand where it is taking us, you are exactly who I write for. I try to make everything make sense for the person in the middle.

I also do not want this to be a monologue. The best version of this is a small group of curious people reflecting on these ideas together, because I want to hear what you are seeing too.

One more bet: We are moving from AI as a copilot, something that helps you while you work, to an autopilot, something that runs whole pieces of work across your tools and on your behalf. Most people are still treating it like a copilot but reality is AI agents are now able to perceive environments, make decisions, and execute multi-step workflows without constant human intervention.

So if you want to understand where AI is actually going, without the hype, the doom, or the jargon, subscribe. Every week I will share what I am seeing inside real companies, what I think actually matters, and how I am shifting my own mindset to be better prepared for the next few years.

And tell me:

Welcome to nickintheloop!

I keep noticing the same split across systems of the hospitality industry that I work on and I was always banging my head as to why the hell wouldn't everyone start adapting to the Agentic AI Era. Upon looking a bit more into it, it is not that straightforward for all companies.

Some companies are racing to make themselves readable by AI agents. They are publishing API docs, launching their MCP servers, doing whatever it takes to let an agent reach in and pull what it needs. Others are sitting completely still, and from the outside it looks like classic inertia. “The fast ones are progressive, the slow ones are dinosaurs”.

This is not a feature you toggle on

Opening your data to agents is not a technical integration with a business-as-usual outcome on the other side. The moment an agent consumes your data directly, two things you used to sell quietly stop mattering.

The first is the interface. If an agent is reading your data and acting on it, your carefully designed UI, is a screen nobody looks at least not all of your customers anymore.

The second is the seat. Per-seat pricing assumes a human is sitting in the seat. An agent does not occupy a seat, it just makes calls, and that quietly breaks the model that built most of modern software. This is not a fringe worry, it is the consensus forecast. Analysts now expect a serious chunk of enterprise software spend to move toward usage, agent, and outcome based pricing over the next few years.

So when a company hesitates to open up, to my understanding, it is not really hesitating over an API. It is hesitating over a pricing change and a business-model change. Most leadership teams sense this even when they cannot articulate it, and that vague sense of threat is enough to make them wait. I've had cases where companies even with API connections and an MCP server would be hesitant to allow integrations of third parties without an established partnership.

Should companies make the next step?

If your value lives in the data and the transaction, opening up to agents is close to pure upside. You have something worth querying, and making it easy to query just expands your reach. If your value lived in the interface, in the engagement, in the habit of logging in and the things you could sell once someone was there, then opening up is closer to assisted self-harm. Same exact move, opposite outcome.

As the agent layer commoditizes, and the new MOAT shifts toward the accumulated intelligence underneath, the operational history and customer knowledge a company has built up over years. The opportunity is to sell that intelligence directly instead of burying it inside a product nobody opens anymore. That is the upside. It is just not free, and it is not the same business.

So aside from some companies that are genuinely slow to adapt to changes, why would someone not embrace the agentic era? To me so far it seems one of the following reasons:

• Company intelligence is not theirs to sell. It is customer data, held under specific consent and, in plenty of cases, a processor relationship rather than outright ownership. Exposing it to a third-party agent, or packaging it as a product, runs straight into the question of whether that was ever the company's data to monetize.

• Lack of capability. I saw some companies with horrible infrastructure, in some cases even servers in basement and data siloed across systems that do not talk to each other, undocumented, inconsistent, and held together by tribal knowledge. Literally. They could not expose it cleanly tomorrow even if the CEO demanded it, and the cost of fixing that, alongside the security and privacy concerns, is exactly what governs how fast anyone moves.

• The gatekeeper problem. Opening up to agents in practice means opening up to two or three model platforms. You are not exposing yourself to a thousand independent buyers, you are exposing yourself to whoever owns the demand. So you may be trading a direct relationship with your customer for app-store-style dependence on a platform that sits between you and that customer and gets to set the terms. The risk is not only that agents bypass your interface. The example I can think of are platforms that are aggregating data across systems on a domain. For example connecting all systems of restaurants into an agentic platform (supply, customer support, marketing etc.) or even platforms like claude and chatgpt which are trying to move towards agentic commerce and helping manage small businesses.

Staying closed can't fully protect you

To be honest, if your data is valuable, agents will reach it whether you build a clean door or not. They will scrape it, work through reverse-engineered endpoints, or access through the use of browser agents. I have spent enough time looking at the tooling for exactly this to know that closed is rarely as closed as people think. It’s just added friction for someone that wants to get access.

Something similar I happened with banks with Open Banking under PSD2 that forced banks to expose customer account data to licensed third parties through APIs. The banks resisted hard, because account data felt like theirs and the relationship felt like theirs. Then a whole fintech layer got built on the rails they were dragged into laying, and the ones who treated it as an opportunity rather than a compliance burden came out fine. It is the cleanest real-world case I know of incumbents being made to open domain data they assumed was sacred.

So what is the actual answer?

I don’t think there is a universal one. There is only a bet each company is placing, whether they realize it or not, and the bet depends entirely on where their value sits. Open up and you risk cannibalizing the model that pays the bills. Stay closed and you risk being invisible to the layer that increasingly makes the decisions. I would bet for sure though that if you can open up and have a solid plan, it most likely should be your way forward.

It is worth noting that the standards here are not even settled since the enterprise pieces of MCP, the auth and the audit logging, are still being worked out. For some companies, being a deliberate fast-follower genuinely beats being first, letting others eat the integration churn and arriving once the rails are stable. In any case, I would say companies should start considering their plans moving forward and some sort of programmatical connection, even with just some REST APIs, even if it's 1-on-1 with their clients, it should be put on the roadmap.

For most of software’s history, the binding constraint was simple: could you build it? Skill meant turning an idea into working code, and that translation was slow, expensive, and rare enough to be valuable on its own.

That constraint is dissolving. Agents now write, test, debug, and refactor faster than any team can by hand. And when building gets cheap, the bottleneck moves elsewhere. The hard question is no longer can you build this? but is this worth building at all?

Which is another way of saying:

If anyone can create a working app from a paragraph, the scarce resource is no longer development work. It’s having something worth developing. Taste, judgment, and the ability to see what should exist become the real differentiators. The people with better ideas and faster learning loops pull ahead of everyone else.

This is the person I think every company will fight to hire, and the person I’m trying to become. I call them the creative engineer.

Not a coder, not a PM, not a designer

A creative engineer is a hybrid. Not just an engineer who picks up tickets. Not just a product manager who writes requirements. Not just a designer who shapes the surface. Someone who holds all of it at once: Judge whether the thing deserves to exist, imagine the thing, and build the thing.

The engineering of course still matters. You can’t have good judgment about systems you don’t understand. The creative engineer hasn’t abandoned the craft. It’s the next evolution from it.

I’d say two habits separate creative engineers from people who are simply fast:

1. The first is looking outside before building. They study users, existing tools, workflows, constraints, and competitors before writing a line. They understand what already exists before creating what doesn’t. Most “new” ideas are solved problems wearing a costume, and the creative engineer can tell the difference.

2. The second is acting to learn. They don’t wait for certainty. They ship something imperfect, put it in front of reality, and let the world correct them. But here’s an important addition: speed without judgment is just slop generated faster. An agent will happily produce thousands of lines of incoherent code an hour. The skill isn’t just shipping fast, it’s knowing what’s safe to break and what absolutely isn’t. Speed that produces insight, not speed for its own sake.

What this looks like in practice

Say our software has a feature that auto-replies to customer emails and reviews. A colleague builds it, and as the deployed engineer I ship it to a restaurant client. They use it, then come back with feedback: close, but a few things are missing.

The standard move, the one most of us make today, is to write that feedback up and carry it back to the dev team. It enters the queue. A few cycles later, a new version appears. Reasonable, safe, slow.

The creative engineer does something different, and does it within the same day. They take the same feedback and, instead of routing it straight to the backlog, they look around first: what solutions already exist for this, who’s using AI well, what’s actually at the frontier and creating real value? They form their own opinion on top of it. Then they vibe-code a quick mockup, visual, maybe only half-functional, could be running on mocked data, that shows where the next version should go. Same day, they take it back to the client and watch them react. Good? A few tweaks? Either way, by the end of the day they’re holding something the standard path takes weeks to reach: a validated direction, real user approval, and a concrete picture of the next version.

Only then does it go to the development team, not as a vague ticket, but as a vision that’s already been pressure-tested against reality.

Same feedback. Same starting point. One person closed the loop in a day, the other opened a ticket.

Most companies are built to reward the opposite. They prize alignment, certainty, and safe execution. They ask people to wait for the spec, stay in their lane, and avoid being wrong.

But the future rewards the people who can turn a vague opportunity into a prototype, a prototype into feedback, and feedback into a decision, fast. The ones willing to challenge how things are normally done inside the building. That’s uncomfortable for organizations optimized for predictability, which is exactly why it’s becoming the rarest and most valuable thing a person can be.

And here’s the uncomfortable part for a lot of the old dinosaur and corporate companies: this isn’t a profile you can simply hire your way into. Unless they’re willing to rethink the culture and values that reward waiting, certainty, and staying in your lane, they won’t just struggle to keep creative engineers, they’ll never manage to attract them in the first place.

What company culture actually needs to look like in the AI era? Might write on this next…

When people talk about the AI paradigm shift, the conversation gets abstract fast.

AI will change companies. AI will change jobs. AI will change daily life.

I agree with all of that. But the more useful question is how. And the best way I’ve found to think about it isn’t through an AI startup or a tech business with hundreds of engineers. I wanted to pick an example of a normal non-tech business. A restaurant.

A restaurant already has plenty of software

A restaurant runs on a surprising amount of software:

• A POS for sales.

• A system for shifts and labor costs.

• Something for payroll and accounting.

• Food delivery apps.

• Inventory tracking.

• Supplier orders.

• WhatsApp messages between managers.

• Spreadsheets.

• Review platforms.

• Table booking tools.

  The list goes and and theres usually on top a few manual processes that only the owner really understands.

The problem isn’t that the restaurant has no software.

The problem is that most of this software doesn’t share meaning.

So the real work becomes context transfer.

Someone has to look at sales, compare it to labor cost, check what was sold, translate that into portions, estimate stock usage, remember what’s in the fridge, message the supplier, update the schedule, and adjust next week’s forecast.

This is work. But most of it isn’t decision-making. It’s moving information from one place to another.

What a connected restaurant looks like

Now imagine the same restaurant, but connected.

Sales data is linked to the items sold. Items are linked to recipes and portion sizes. Portions are linked to ingredient cost. Ingredient usage feeds into supplier orders. Labor cost is tied to revenue. Manager updates from WhatsApp: Shortages, remaining quantities, issues during service, they all get pulled into the same operational context. Reviews are connected to specific shifts, dishes, and busy periods.

The restaurant can suddenly ask much better questions. Which dishes are actually profitable, not just popular? Were we overstaffed for the revenue we made on Tuesday? Are bad reviews clustering around certain shifts or menu items?

These aren’t AI-magic questions. They’re just questions that require pulling context from five systems at once, which is exactly why nobody asks them today.

The important part isn’t that an AI magically runs the restaurant. The important part is that the restaurant becomes legible enough for AI to help surface things humans would otherwise miss, and to automate the flows that normally eat up time.

The middle layer

This is where I think the real shift sits.

At the bottom, you have all the raw information: POS data, labor, inventory, recipes, suppliers, reviews, messages, payments, bookings, spreadsheets.

At the top, you have AI agents or automations that can answer questions, suggest actions, trigger workflows, or prepare decisions ready for the restaurant manager/owner to act upon.

In between, you need something that makes the information usable. A layer that connects, structures, summarizes, tags, and retrieves the right context at the right time. Not necessarily one perfect database.

I don’t think anyone knows the final form yet, and it’s still an open question whether that layer gets built by the business itself, by vendors, or by some new category of tooling that doesn’t really exist yet. But the direction is clear. Businesses will need a way to make their scattered information accessible and meaningful to AI systems.

You can already see this emerging. Some restaurant tools are starting to connect sales, labor, inventory, and forecasting. Other individual softwares that serve only one purpose create API endpoints for their software, MCP servers and soon ability for agent-to-agent communication. At the same time, platforms like Claude, Toqan and others are adding integrations and MCP-style connections so agents can work across tools instead of living in a chat box. Agents themselves are starting to feel less like isolated assistants and more like interfaces across software.

Why we’re still early

Most businesses haven’t really used any of this yet. Many are still at “we use ChatGPT and we pass our spreadsheet reports.” That’s useful, but it’s not the paradigm shift.

The paradigm shift is when the business itself becomes more readable, connected, and actionable. Don’t get me wrong, it is a difficult thing to do on top of an already established business and it will be a bit messy at the start but I think it is a mandatory step that the sooner companies adapt to it the better. Competition across businesses is fierce and the people who are first will start seeing the benefits the earliest.

And this isn’t only about restaurants. The same logic applies to gyms, agencies, SaaS companies, and even individuals to increase their productivity. We all have scattered context: calendars, messages, notes, receipts, tasks, documents, habits, projects, and a lot of our time goes into transferring that context between tools and between people.

AI gets dramatically more powerful when it isn’t starting from a blank chat window every time.

If you are creating a new business, you are in the perfect position

If you are building a business from scratch, this is a huge opportunity right now.

Existing companies have to retrofit connected context into old workflows, old data structures, old habits, and old teams. That’s hard. A new company can design itself around connected context from day one. It can make its operations readable to agents from the start. It can automate the boring transfer work earlier. It can give every person more leverage.

I don’t think this means companies become tiny and no one is needed. I think the roles change.

The person who used to register information manually, move numbers between systems, or chase context from five different people probably won’t do that same work in the same way. But the company also becomes capable of scaling further, serving more customers, and running more complex operations. People end up owning bigger chunks of the business, with AI handling more of the context gathering, monitoring, and first-pass execution.

The future role is less “information mover” and more “operator” or “orchestrator.”

The gap will compound

It is difficult for me to map exactly how this would look like. Softwares could act as providing “domain expertise” from all their accumulated data. Every company could build on the fly their ideal dynamic dashboards. Maybe we will end up having autonomous restaurants for example with the only component needed the expertise of the business owner (until we unlock continual learning that is).

In any case, it’s hard for me to believe companies will operate the same way once this becomes the norm.

If one restaurant connects sales, labor, inventory, suppliers, reviews, and manager notes into an intelligent operating layer, and the restaurant across the street still runs on screenshots, WhatsApp messages, spreadsheets, and memory, the gap won’t stay small. It will compound. The connected business will move faster, see more, and waste less time. The other one will just feel slower every year.

The same is true for bigger companies. And 100% for individuals too. (Life assistant apps, I’m waiting for you).

That’s the part of the AI shift I find most interesting. It’s not anymore the fact that AI can write, code, or answer questions. Now it’s that AI changes how information flows through between systems and businesses. And once information flows differently, the business itself starts to operate differently.

Next up: what the middle layer actually looks like, and how jobs change when companies are designed around agents from day one.

AI-native does not mean "everyone in the company uses ChatGPT."

That is the easy version of the idea, and honestly I think it misses the more interesting part. To me, an AI-native company is a company where the information that flows through the business is connected from the start. Customer feedback, support tickets, product decisions, meeting notes, internal docs, metrics, all of these things should not live in separate corners where only a few people know what is happening.

The company itself should be readable. Not only by people, but also by agents.

A simple example is a software company where a customer sends a support ticket saying the onboarding is confusing. In a normal company, that ticket does not automatically become useful company knowledge. It usually has to travel. Someone shares it in Slack. A product manager asks if this has happened before. Someone checks older tickets. Someone looks at which customer sent it. Someone writes a short document for a roadmap discussion. Then, eventually, it becomes part of a meeting where the team decides whether onboarding is actually a problem worth fixing.

By that point, a lot of the work was not solving the onboarding issue. It was moving context around which is a highly unproductive way to spend your time.

This is a big issue in conpanies which I believe can be fully alleviated. A lot of company work is not creation, but translation. Translating a support problem into a product problem. Translating customer pain into a roadmap item. Translating scattered notes into something leadership can understand. Some small part of this is necessary, of course, but a lot of it exists because the company knowledge is fragmented.

This is called the human middle layer.

In an AI-native company, the same ticket should enter the system differently. It should be stored in a way that makes it easy to connect with similar tickets, the part of onboarding it refers to, previous decisions around onboarding, and simple experiments the team could try. I do not mean this in a complicated enterprise-software way. I just mean that the information should not arrive as an isolated piece of text that someone has to manually chase across five tools.

Then an agent can help answer the obvious first questions effortlessly. How often is this happening? Which customers are affected? Is there a pattern? What could we try first?

The human still makes the decision. That part matters. (I would argue that we can push human decision to a much later step but that's for another post). The goal is not to remove judgment. The goal is to stop wasting so much human energy on collecting the same context again and again before a decision can even happen.

Applying this principle brings me to a second part to this thesis that I think is just as important and probably most companies will fall in the trap of neglecting it.

Making a company queryable does not mean dumping the whole company into a giant prompt. That is the brute force version, and I think it scales terribly. More context is not automatically better context. If you give an LLM every ticket, meeting transcript, Slack thread, dashboard, and document, you also give it noise, old information, contradictions, and a lot of tokens that have nothing to do with the decision in front of you.

So the AI-native company needs a new middle layer between raw information and the LLM.

Raw information is everything the company produces: tickets, emails, calls, docs, notes, metrics, decisions. The middle layer is where this information gets cleaned up and connected. It adds simple structure: what product area is this about, which customer problem does it relate to, what has been decided before, what other examples look similar, what action might be worth considering next. Only then should the agent get involved. The agent should not need to read the whole company every time you ask a question. It should retrieve exactly the context it needs for the task. This is where I think the advantage for new companies becomes interesting. A large company can try to retrofit this later, but the old habits are already built in. The tools are disconnected. The meetings are already the glue. The knowledge lives in people’s heads, old docs, private chats, dashboards, and processes nobody fully owns.

A new company can design the flow differently from day one. It can decide that whenever important information enters the company, it should become part of a connected system that both people and agents can use.

That is the real AI-native advantage in my mind and why small AI-native startups are able to move so fast and scale even faster. Not using more AI for the sake of it. Not spending more tokens. Not replacing every human decision.

It is building a company that needs less translation/friction before work can happen.

In the next post I will share in detail how this middle layer could look like by looking at an example of a small AI startup. Thanks for reading the whole post!

I have been working a lot lately with AI agents that connect to the software where our work lives, our calendar, our inbox, our notes. Almost all of that connecting happens one way. The agent calls into a tool, the tool answers. It is a one-sided conversation. A few weeks ago a question started forming. What happens when the tool on the other end is also an agent?

I remembered Google had announced something called the Agent-to-Agent protocol, A2A, last year and I had filed it away as “interesting, check later.” It felt like a good moment to actually go back and see what it is trying to achieve.

MCP and how A2A can compliment it

In my last post I mentioned MCP as the thing that lets an agent reach into your tools. It is genuinely useful. An MCP server wraps a piece of software and exposes its capabilities in a clean, structured way, so your agent does not have to hand-roll integrations or figure out what each API expects. Imagine you ask your agent to plan a weekend trip. Through MCP it can call into a flight search, a hotel database, a calendar, a weather feed. Each of those is a tool with a clean interface.

But here is the part that is easy to miss. MCP makes the tools clean. It does not move any of the thinking. Your agent is still the one deciding which tool to call, in what order, with what parameters, and what to do with the response. The airline’s MCP server cannot reason. It can only execute. So your agent has to know enough about flights to ask the right question, enough about hotels to evaluate the answer, enough about weather to weigh it against your dates. It is still a generalist trying to make decisions across a dozen specialist domains.

This works for a lot of things. It will keep working. But there is a ceiling, and you hit it as soon as the task gets ambiguous. “Find me a good flight to Lisbon” is not a function call. Good means something different to every traveller, in every season, for every budget. To answer it well, something on the other end has to actually understand flights or you need to integrate this information to your agent which takes time and expertise.

A2A imagines a different shape. Instead of your agent calling into the airline’s MCP server and reasoning about the response itself, the airline ships its own agent. That agent has access to the airline’s data and tools through its own MCP setup, but it also has the reasoning to use them well. It knows what a good flight means in its domain. It knows when to ask a clarifying question. It can run a whole sequence of internal lookups, evaluate options, and hand back a clean answer.

Your agent becomes the generalist that knows you. The airline’s agent becomes the specialist that knows flights. Your agent says “find me a flight from Amsterdam to Lisbon next Friday afternoon, three hours max, window seat preferred, under 200 euros.” The airline’s agent figures out the rest. Same for the hotel. Same for the weather service. Same for whatever else the trip needs.

The way this works under the hood is simpler than it sounds. Each agent publishes a small file at a known web address called an Agent Card. It is essentially a digital business card. It says who the agent is, what it can do, how to reach it, and how to authenticate. When your agent needs help with something, it looks up the right agent card, sends a task, and waits for the result. The whole thing runs on the same web protocols everything else runs on, so it does not require new infrastructure.

The two protocols are not competing. They stack. A2A is how your agent reaches another agent. MCP is how that other agent reaches its own tools. The shift is where the reasoning lives. With MCP alone, the reasoning sits entirely on your side. With A2A in the mix, you can offload it to the side that knows the domain best.

A2A was launched by Google in April 2025 and donated to the Linux Foundation two months later, so it is an open standard now, not a Google product. Three weeks ago, on the one-year mark, the Linux Foundation announced more than 150 organisations supporting it, with real production deployments in supply chain, finance, insurance, and IT. The founding partners include AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow. This is past the pilot stage.

My thoughts on A2A

Almost all of the production use right now is enterprise, company to company. One company’s agent talking to another company’s agent inside a partnership or integration. The end user does not see any of it, they just notice (maybe) that the part of their software that depends on a third-party system works better than it used to. The trip-planning world I described, where your personal agent talks to the airline’s agent directly, is not really the world we live in today. That is the direction I think that the standard is pointing towards.

The whole thing only works if both sides show up. A2A is a standard for talking between agents, but it cannot conjure agents that do not exist. If the airline only ships an MCP server and not an agent, your agent is back to doing the reasoning itself. The value of A2A scales with how many of the systems you depend on have actually built agents on the other end, and there is no guarantee every vendor will. Some will stop at MCP, decide that is enough, and let the calling side keep doing the thinking.

Not every workflow needs multiple agents either. Sometimes a single agent with good MCP access is the simpler, faster, cheaper answer.

What I think and hope will happen over the next months is that more vendors ship agent endpoints alongside their MCP servers, and the AI tools you already use start delegating to them quietly. You will feel it as fewer corrections, less back-and-forth, outputs that come back more complete on the first try, because a specialist on the other end handled the part it knew best.

In my next post I want to look at what this does to the software you currently pay for. Because once your agent can get the answer without you ever opening the airline’s website, the question of what that website is even for starts to look different. The way we pay for it is already changing too…

Over the past few weeks, I noticed a small but important change in how I was using AI. I was not opening Claude only to ask questions anymore. I was opening it to check what had already happened: a daily news brief, a scheduled search for discounted clothing, a research task that had run in the background, notes that had been collected and organized before I sat down to write.

The interaction felt different. Instead of always initiating the work myself, I was reviewing work that an AI workflow had already started for me.

What’s actually new (and what isn’t)

Scheduling itself is not new. Developers have always had cron jobs, scripts, queues, and background workers. If you knew how to write code, you could always schedule something to run on its own. What feels different now is that this pattern is moving closer to everyday AI products and personal productivity workflows. The scheduling layer is becoming less of a developer-only primitive and more of a user-facing interaction model.

But I want to be careful here, because I think a lot of what gets called a “scheduled agent” today is something more modest: a saved prompt that runs at a certain time, pulls some context from your tools, and produces an output. That is genuinely useful. It is not the same as a persistent autonomous agent with its own runtime, ongoing state, and a heartbeat loop that wakes it up to make decisions on its own.

I first noticed the difference when I came across OpenClaw, an open-source personal agent that runs locally and uses a heartbeat scheduler to wake itself at intervals, check a workspace, and continue progressing toward goals without you prompting it. That is different than scheduled prompts. I then tried ChatGPT’s scheduled tasks, which honestly performed badly for my use cases. More recently, OpenAI launched Workspace Agents, designed for longer-running workflows, tool access, and team-level permissions, though I have not properly tried them yet. For a few weeks now, I have been using Claude Cowork’s scheduled tasks for recurring delegated work like reports, briefings, and summaries.

Some of these are simple scheduled LLM calls. Some are tool-connected workflows. Some are early attempts at persistent agents. But they all point in the same direction: AI is moving from something you only ask, to something you can start assigning recurring work to.

What I am actually delegating

Since then, I have been using these patterns more often, handing off more manual recurring tasks to Claude. Scheduled jobs to surface AI news, monitor things I might want to buy, support my writing workflow, and automate repetitive work in my day job.

For this blog, I have a simple system. During the week I drop rough ideas, often while talking to Claude, into an LLM-wiki-style setup that organizes them for me. On the weekend, I use those accumulated notes to turn the better ideas into a post. It is not fully autonomous, and it is definitely not perfect. But the productivity shift is obvious. Parts of the work and research now happen before I sit down to do them.

Scheduling, tools, and context

Three pieces have to come together for any of this to actually work.

Scheduling is the most boring-sounding part and probably the most important one. A chatbot is something you go to. A scheduled workflow is something that comes back to you. Once a task runs every morning, every Friday, before a meeting, or whenever a trigger fires, the relationship changes. You are no longer only prompting, you are delegating a recurring responsibility.

Tool access is the second part. An AI workflow becomes much more useful when it can reach where your work already lives: Slack, Drive, Notion, Linear, GitHub, email, calendar, your file system. Without tool access, the model is mostly producing text from whatever you paste into it. With it, the model can gather context, compare sources, update files, and move work across systems.

Context is the third part, and it’s where I think we still have the most work to do. I am deliberately saying context, not memory, because the word memory gets overloaded fast. In most current systems, what looks like memory is really structured context: markdown files, notes, instructions, preferences, summaries of previous runs, feedback that gets loaded into the next session. Even that is useful, a simple LLM wiki gives the system a place to fetch assumptions and workflow-specific information. But it is not the same as true persistent memory, and in my own workflows the limitation shows up regularly. Scheduled tasks include irrelevant information, miss context I assumed they had, repeat things I already corrected.

This is why I think continual learning, or at least better persistent memory systems, will become one of the most important pieces of the agent stack. My friend Andreas, who is doing a PhD in continual learning on LLMs, writes about this on his Substack which is worth reading if you care about how agents can become genuinely adaptive over time.

Still not cracked, but getting closer

I am excited about this direction, but I do not think we should pretend it is solved. For most people these systems are still not easy enough to set up, maintain, and trust. You spend time defining the workflow, connecting tools, refining prompts, checking outputs, and adjusting when things break. The workflow runs automatically, but the setup is still manual and needs maintenance.

So I would not say this has fully moved from power users to normal users yet. It is moving from developers and AI enthusiasts toward more tech-savvy everyday users. There are products targeting normal users too like lifestyle assistants that read your calendar and inbox and propose actions but we are not fully there yet.

What we clearly have now for sure are narrow recurring workers: AI systems that handle specific jobs inside existing workflows. The weekly research brief. The meeting prep. The inbox summarizer. Not general autonomous employees, but specialists you can hand a recurring responsibility to.

What stays human

The layer being replaced is not “thinking.” It is the repetitive execution layer: searching, checking, summarizing, monitoring, formatting, comparing, drafting, updating, following up. A lot of knowledge work is made of these small mechanical steps between an idea and an output, and recurring AI workflows are starting to compress that layer.

What remains human, at least for now, is the direction. What are we trying to say? What matters? Which angle is actually interesting? What should be ignored? For creative work especially, I find AI still struggles to truly decide what should be concluded. It can give options, structure arguments, produce drafts, but the final judgment still needs a person who actually cares about the outcome.

That is what makes this exciting rather than depressing. As AI removes more of the repetitive execution layer, the bottleneck moves to taste and direction. The boring work gets cheaper. The need for clear thinking gets more obvious.

The interesting question is no longer “what can I ask AI?” It is “which parts of my work can I safely assign, and what context does the system need to do them well?”

I would like to hear from you. Are you using any similar tools and how effective are they? Where do you see this shift progress towards in the next months?

Leave a comment

Your salary doesn't matter. What you keep does.

I'll be honest. I went back and forth on whether to write this post. I mostly try to keep the blog tech-related, and I'm definitely not a financial advisor but I said I'll give it a shot and write on the things that troubled me in the recent months since I am very content with the outcome. This is just my personal take. But the more I thought about it, the more I realized that personal finance might be the most important skill when it comes to actually becoming independent as a grown-up. And I think a lot of people in their 20s are struggling with it way more than they'd admit.

I spent a significant amount of time last year learning everything I could about managing money: how to save, whether to invest, and if so, where. The topic is massive and could easily turn into a ten-part series. So instead of going deep on everything, I'm going to keep this to the core principles and what I personally figured out. Where something already exists and explains it better than I could, I'll link to it directly. No need to rephrase what's already been said well.

The Moment It Gets Real

Here's the situation most of us find ourselves in at some point: you finish your studies, you get a job, your parents stop financing your life, and suddenly you're paying for everything. Rent, groceries, utilities, restaurants, entertainment, everything adds up fast. And if you're not paying attention, you can very easily end up spending way more than you should without even realizing it.

The basic idea is straightforward. You earn a salary. You use part of it to cover your living expenses. And then, ideally, you save some of what's left. You save for short-term goals, like a vacation or a nicer computer, and for long-term ones, like a car or eventually putting down a deposit on a house. Simple enough on paper. Actually doing it consistently? That's where it gets tricky.

I found a huge amount of help from the r/personalfinance wiki, which I'd genuinely recommend reading if you haven't. Some parts are more US-specific (tax-advantaged accounts, retirement funds, etc.), but the general framework of budgeting, building an emergency fund, paying off debt, then start saving and investing, applies pretty much everywhere.

The Uncomfortable Truth About Starting Points

I want to address something that I think doesn't get talked about enough: your family situation plays a massive role in how your financial life starts.

Think about it. Imagine a person who graduates already carrying debt, can barely make it month to month, and is trying to pay that off before they can even begin to save. If you run the numbers on an average European salary, you'll see that saving a few hundred euros a month means it could take your entire life to scrape together enough for a mortgage, which you'll then spend the rest of your life paying off.

So here's my number one piece of advice, and it might be unexpected: if you're a parent or planning to become one, invest in your child's future early. Make sure they can get a proper education without going into debt. If possible, set aside some money for them while they're young. As far as I know, there are savings accounts for children with better interest rates that work well for this. That money can serve as their emergency fund when they start out. No debt, a good education, and a financial cushion means they can start saving and investing from day one instead of spending years digging out of a hole first.

I was fortunate enough to be in that position. My parents aren't finance experts or anything, but they understood the basics of saving. They financed my studies and accommodation abroad and made sure I had some money set aside by the time I started working, partly from their own savings, partly from me being careful with what they sent me during uni. Because of that, when I got my first full-time job, I was able to start putting money aside immediately for travel, for long-term investing, for side projects, all while still living comfortably.

Now, obviously, none of this is in your control if you're not a parent. And not having that head start isn't the end of the world. I'm pointing it out because it's real, it matters, and pretending everyone starts from the same place doesn't help anyone. Whatever your starting point, the principles still work, they just take longer to kick in.

The Only Principle That Actually Matters

My dad used to tell me something that stuck with me: it doesn't matter if you're making €1,000 or €100,000, what matters is how much you have left at the end of the month. A person earning €1,000 and saving €100 has more money saved than someone earning €100,000 and spending every cent of it.

That's the whole game. You need a surplus at the end of every month. It doesn't matter what your income is. If there's nothing left, you're not making progress. And from what I've seen so far in my circle, most people don't actually have a clear picture of what they're spending. That's the first thing that needs to change.

How I Actually Track My Money

There are plenty of ways to start budgeting, and I'll keep this practical.

If you're using a modern bank app like Revolut (or any neobank, really), you probably already have a basic budgeting system built in. Transactions get categorized, you can set spending limits per category, and you can see where your money's going at a glance. That's a perfectly fine place to start, and it's what I used initially.

But personally, I wanted more control. That's how I ended up switching to Actual Budget, which is an open-source, privacy-focused budgeting app that uses the envelope budgeting method. There's also YNAB (You Need A Budget), which is popular especially in the US, though it requires a subscription. I'm not advertising anything here, just sharing what I use and what I've seen others use.

The idea behind envelope budgeting is simple: you assign every euro of your income to a specific purpose. Groceries, rent, entertainment, subscriptions, savings, each one gets an "envelope." When you spend money in a category, it gets subtracted from that envelope. If you overspend in one area, you have to move money from another envelope to cover it. You can't just go negative and pretend it didn't happen. It forces you to be honest about your spending.

Setting up Actual Budget does take a bit of initial effort, maybe a day or two if you're comfortable reading documentation and doing some light setup (it's a self-hosted app, so there's a small technical barrier but nothing crazy, you can follow their hosting solution on PikaPod for around 1 euro / month. But once it's running, it's smooth.

Here's what it did for me in practice. I created categories for everything, groceries, rent, restaurants, shopping, subscriptions, travel, side projects, investing. Almost immediately, I noticed things. I saw exactly how many subscriptions I was paying for. I realized I was spending too much on eating out, so I cut that down.

The result? I'm now able to save approximately a third of my salary. For someone who recently started working full-time, I'd say that's a solid starting point. But more than the number, it gave me a kind of organizational clarity I didn't have before. I can save for travel, set aside money for side projects, and invest, all without guessing.

What I Do With the Surplus

Once you're saving consistently, the question becomes: what do you actually do with that money? I think some of it should go into investing. Without going into too much detail here (maybe I'll write a separate post on this, let me know if you're interested), here's my current approach.

I invest my long-term savings into an all-world ETF, specifically one that tracks the FTSE All-World Index (like VWCE). To keep it very simple: it means you're buying a small piece of stock from the top-performing companies across both developed and emerging markets worldwide. The allocation is roughly 63% US, about 6% Japan, and the rest spread across the UK, China, Canada, and others. The money I put in there, I'm aware I won't touch for at least the next decade.

From everything I researched, this felt like the most sensible approach for now. It might change in the future, but when you look at your options for growing money, they basically boil down to: invest in the stock market, buy assets that might appreciate in value (real estate, collectibles (which is tricky and requires research)), invest in yourself and your skills (sounds cliché, but it's probably the highest-ROI move you can make), or invest in a business or side project.

That last one is actually why I keep a small, separate budget for side projects. It's not a huge amount, but it gives me the freedom to try things without overthinking it. For example, the domain for this very blog, paid for with my side project budget. It's a small thing, but being able to make those moves without stress is exactly the point.

Why Starting Early Matters

I wasn't really aware of how much thought personal finance requires until about a year ago. But in essence, it's actually pretty simple once you start doing it, and the earlier you start, the better.

If you start investing early, you get the benefit of compounding over time (assuming the world still exists when we're older, but let's stay optimistic). And beyond the financial math, the habits you build now get harder to establish later, especially once you start having kids, sharing expenses with a partner, or dealing with more complex financial situations. If you're cohabiting, by the way, I'd really encourage setting up shared expense tracking with your partner. It makes things so much smoother down the line.

I think the ideal scenario would honestly be for parents to start teaching these things when their kids are young, in a simplified way. I remember being maybe six or seven years old, getting about two Cypriot liras from my parents for school lunch. I'd buy a halloumi bread and a chocolate milk, and I'd still have about 50 cents left over. So naturally, I'd go ahead and buy a stack of cookies at five cents each and hand them out to my classmates. Philanthropy before I even knew the word, I suppose. Not exactly the savings lesson my parents had in mind, but the spirit was there.

The Part Nobody Talks About: It Feels Good

Here's something I didn't expect. Tracking my money doesn't feel restrictive at all. It actually gives me peace.

When I know my budget for the month, say for eating out, I know exactly when it makes sense to go to a restaurant and when it doesn't. I can choose to spend €5 on a quick meal one day and €40 at a nicer place another day, and in both cases, I know where I stand. I've never once felt like I was pressuring myself to cut back or restrain my spending in a way that made me unhappy.

I think that's because awareness changes your behavior naturally. When you know the numbers, you just make better decisions without even thinking about it. You stop being an impulsive buyer, not because you're restricting yourself, but because you simply see what's happening. It's less about discipline and more about clarity.

Wrapping Up

Personal finance isn't glamorous. But I genuinely think it's one of the most impactful things you can figure out in your 20s. The core of it is dead simple: know what you earn, know what you spend, make sure there's something left, and put that something to work.

If you're already doing this, amazing! Feel free to drop a comment and tell me how you approach it or how I could improve my system. If you're not doing it yet, start. It doesn't need to be complicated. Even just looking at your transactions from the past few months and categorizing them is a solid first step. I would also recommend everyone to take a free course online on wealth management as they grow older. It is definitely something on my to-do list for the upcoming years.

I might do a follow-up post diving deeper into the investing side of things. If that's something you'd want to read, let me know.

Take care, and stay in the loop.

Useful links:

• r/personalfinance wiki — Great starting framework for managing your finances (some US-specific content, but the principles are universal)

• Actual Budget — Open-source, privacy-focused envelope budgeting app

• YNAB (You Need A Budget) — Popular budgeting app (subscription-based)

For years now, we’ve been told that powerful AI requires powerful servers. That to use it, we must surrender our data to the cloud. But what if that story’s ending is changing? What if the future of intelligence isn’t centralized, it’s personal and local?

That’s the challenge ToolNeuron is taking on — an active project built by a young developer who believes privacy and performance don’t have to be enemies.

I recently sat down and had a talk with Siddhesh, an Android and AI developer, and what I found was more than just a clever app. It is a vision for a new kind of AI future: local, private, and completely user-controlled.

From Curiosity to Creation

Siddhesh didn’t take the traditional path into AI. He started tinkering with Android development at 14 — self-taught, driven by curiosity, and fueled by trial and error. That experimentation evolved this past year into a deep interest in artificial intelligence, specifically Edge AI.

Edge AI is the process of running artificial intelligence algorithms directly on a local device at the “edge” of a network, rather than sending data to a remote cloud server for processing.

Now, while pursuing a Diploma in Computer Software Engineering, he’s building ToolNeuron, a personal AI hub designed to put users — not corporations — in control of their data. What began as a side project became a mission: to make AI both private and accessible for everyone.

“Your data is going to train a lot of AI models,” Siddhesh told me. “You don’t want other people knowing what’s going on in your life.”

What Is ToolNeuron? Your AI Hub in Your Pocket

At its core, ToolNeuron is an Android app that lets you run language models directly on your device — no cloud connection required. It’s like having your own private ChatGPT that you can fully customize, extend, and use offline.

Built with llama.cpp, native C++, Kotlin, and a sleek UI using Jetpack Compose, it’s designed to make edge AI both powerful and practical. The privacy-first philosophy means your data stays exactly where it belongs: with you.

Key Features

Dual Mode Operation
Run models fully offline or access 100+ online ones using OpenRouter’s API. Offline for privacy. Online for flexibility.

Voice Integration
Supports text-to-speech (TTS) and speech-to-text (STT) entirely offline, powered by Sherpa-ONNX. Eleven built-in voices. No internet.

DataHub: Extend Knowledge Without Retraining
Attach dynamic datasets to expand what the AI “knows.” Think local modular RAG.

Plugin System & Extensibility
Community-built plugins for web search, automation, and daily tasks. A future marketplace is planned.

Fluid Model Switching
Switch models mid-conversation without losing context — general assistant to coding model instantly.

Why ToolNeuron Matters

We’ve traded privacy for convenience for years. Smarter AI in exchange for more data surrender.

ToolNeuron flips that trade-off.

Running AI locally means your assistant is truly yours. You decide what it learns, what it accesses, and where data goes — if anywhere.

This is digital sovereignty.

Yes, on-device AI has limits. Large models strain mobile hardware. But mobile chips are accelerating fast. ToolNeuron already proves this future works today in early form. CPU-only for now on Android, with GPU support planned.

The project is open-source and evolving fast.

The Bigger Picture: Local AI and the Future of Privacy

ToolNeuron reflects a broader shift: from centralized intelligence to personal computing.

Local assistants. Edge inference. User-driven ecosystems.

Open-source keeps it collaborative and transparent.

Meanwhile, big tech pushes “on-device” AI with quiet hybrid pipelines:

Google’s AI Edge Gallery
https://github.com/google-ai-edge/gallery

Microsoft’s Mu models on Copilot+ PCs
https://blogs.windows.com/windowsexperience/2025/06/23/introducing-mu-language-model-and-how-it-enabled-the-agent-in-windows-settings/

Local models — but telemetry still flows upstream.

True privacy means no silent data dependencies.

A New Wave of AI Independence

ToolNeuron isn’t disruption for hype. It’s empowerment.

Giving everyday users the autonomy over AI that corporations have hoarded for years.

The roadmap includes desktop companions, cross-device sync, and multimodal models — but the principle never changes:

AI that belongs to you.

What happens when our digital assistants stop living in the cloud and start living with us?

Links

Website:
https://tool-neuron.vercel.app/

GitHub:
https://github.com/Siddhesh2377/ToolNeuron

Early Access Signup:
https://tool-neuron.vercel.app/signup.html

** This is an old post that I transferred from my old blog website. This was the status around late 2025. I will make a new post about the recent updates with Claude Opus 4.6, gpt-codex 5.3 and agentic fleets **

Why now?

We finally have real competition in IDE code agents! I’ve been using ChatGPT models for a few years now (since 2020) with a Plus subscription on the desktop app and on my phone. It works for most stuff and now with GPT-5 it’s been incredible for coding, but context-juggling is an issue. You bounce between your IDE and a chat window, copy and pasting files, code segments and logs back and forth.

In my opinion, every developer can benefit from using a coding agent nowadays. I'll take you through what I've been recently using and you can pick something to try for yourself if you want.

My Setup

I am a VS Code IDE user. Over the last year I also started using GitHub Copilot, an AI coding assistant inside VS Code. With my university email I get Copilot Pro (normally ~$10/month) for free. This lets me use chat/agent mode with different models like Claude Sonnet 4, Gemini 2.5 Pro, and recently GPT-5.

Apply here if eligible:
Copilot-Student

Since GPT-5 landed this month, Copilot’s agent mode became much better and my default. Claude Opus 4.1 sits behind Pro+ ($39/month), so before GPT-5 I mostly compared Claude Sonnet 4, GPT o3-mini-high and Gemini 2.5 Pro.

With GPT-5 on Copilot I became far more productive — until I hit Copilot’s monthly limit within two weeks. Time to diversify.

I ended up running three agents: Gemini CLI, Codex, and GitHub Copilot.
I only pay for ChatGPT Plus (~€21/month).

Side note on Claude Code CLI:
I’ve bounced between subscriptions over the years (ChatGPT, Gemini, Claude). Claude’s limits were a constant issue and I’ve seen reports of people racking up high bills. I already liked GPT for daily work and used Claude Sonnet 4 only inside Copilot — so I skipped Claude Code.

Let’s look at the three agents I actually use.

Gemini CLI + VS Code “Gemini CLI Companion”

What it is: Gemini’s open-source terminal AI agent. Launched June 25, 2025. Free, open, moving fast. Rough start, but improving quickly.

Gemini CLI announcement:
https://blog.google/technology/developers/introducing-gemini-cli-open-source-ai-agent/

Key points:

• Generous free tier with personal Google account: 60 requests/min and 1,000/day
• Access to Gemini 2.5 Pro with a 1M-token context window
• Fully open source with frequent releases
• New VS Code companion extension with inline diffs and editor awareness

VS Code extension Link

How I’m using it:

I keep Gemini CLI as my third option. I reach for it when Copilot/Codex quotas hit or when I’m working in a huge codebase where the 1M context shines.

Docs:
https://github.com/google-gemini/gemini-cli/blob/main/docs/cli/index.md

OpenAI Codex CLI (now with IDE integration)

Where it started:

Codex Web launched in May 2025 with cloud sandboxes connected to GitHub repos. Interesting idea, but unusable for me due to HPC environment friction.

OpenAI post:
https://openai.com/index/introducing-codex/

What changed:

• Codex CLI now runs locally and is included with ChatGPT Plus
• Native IDE extensions for VS Code, Cursor, Windsurf

Codex CLI:
https://github.com/openai/codex

IDE integration:
https://openai.com/codex/

Usage limits (Plus):

OpenAI doesn’t publish a hard cap, but guidance suggests roughly 30–150 local messages per 5 hours, with an undisclosed weekly limit.

Help Center:
https://help.openai.com/en/articles/11369540-codex-in-chatgpt

How I’m using it:

Running it in parallel with Copilot and seeing which becomes my main workflow.

GitHub Copilot

This has been my primary coding agent the longest. Big strength: multi-model support across vendors with a clean UX and agent mode.

https://github.com/features/copilot

Plans & limits (individuals):

• Free: 2,000 completions/month + 50 premium requests
• Pro: Unlimited completions + ~300 premium requests/month (free for students)
• Pro+: 1,500 premium requests/month + full model access

Usage rate info link

Models:

Switch models per chat or completion (GPT-5, Claude Sonnet 4, Gemini 2.5 Pro, etc.).

Context windows:

Context depends on client and model. For example Copilot Chat had 64k with GPT-4o even when the model supported more. Don’t assume max context carries over.

References:
https://github.blog/changelog/2024-12-06-copilot-chat-now-has-a-64k-context-window-with-openai-gpt-4o/
https://github.com/openai/codex/issues/2002

How I’m using it:

Still my main coding agent. I mix fast models for unlimited completions with bigger ones for premium requests. Codex + GPT-5 is now in heavy rotation too.

Comparative reflection (when I reach for which)

• Gemini CLI + Companion
Huge context and generous free tier. Perfect backup and great for large repos.

• Codex
Already included with ChatGPT Plus. GPT-5 locally has been excellent.

• Copilot
Best multi-model flexibility and free Pro for students. Caveat: big context windows don’t fully translate inside Copilot.

Conclusion

• Agents inside the IDE massively boost productivity — but only if you scope prompts carefully and review diffs. They still love replacing giant chunks of code.
• I’ll keep using all three: mainly Codex and Copilot, with Gemini CLI as my flexible third option.
• Works smoothly on Windows and WSL.
• All support project-aware config files, though I prefer planning in chat and making small targeted edits.
• I haven’t explored MCP server integrations yet.

If project-aware configs or MCP servers significantly boosted your workflow, feel free to share useful use-cases.

I’ll keep experimenting with these agents and see where it lands. If this pushed you to try one, the post did its job.

In April 2025 I joined the UtrechtInc Student Validation Program with a project of mine and my 5 colleagues, CalvAlert, and it turned out to be one of the most valuable experiences I’ve had this year.

I first heard about UtrechtInc after my internship at Beyond Weather, one of the startups based there. UtrechtInc is one of the top 10 university-linked incubators worldwide, and it has a vibrant mix of startups, office spaces, monthly networking events, and tailored programs on early-stage startups needing ideation, validation, or acceleration.

A Quick Note on CalvAlert

CalvAlert is an AI-powered computer vision calving monitoring system for dairy farms. The idea is simple but important: detect calving events (cows giving birth) and difficult births (like dystocia) in real time so that farmers can intervene when needed.

CalvAlert results in:

• Better animal welfare
• Saved labor costs for farmers
• Prevention of calf deaths, which are both costly and unwanted

This post isn’t about CalvAlert itself, but about my journey inside the program — what I learned, who I met, and how it helped shape our next steps.

If you are interested in our project, feel free to visit our website:
https://withlency.com/

That’s all I’ll say here.

Getting into the Program

I knew about the program since September 2024, and my team was waiting for the next opening in April. The process was straightforward:

• We filled an application form and applied to the program
• Then, we submitted a one-pager, a single-page document that summarizes key information about our project
• Got shortlisted and went ahead and pitched our project in person

From there, we were accepted along with about 10 other startups.

Inside the Program

The program was 3 months long. It included a series of classes and workshops that were especially helpful since all of us came from CS and AI backgrounds. Topics included:

• Marketing
• Pitching
• Business plan validation
• Value proposition design

There were also community events for networking as well as sharing your project to others to get feedback which allowed us to improve our website and gave us new ideas on how to refine CalvAlert. These events were my favorite since through them I got to meet new entrepreneurial people, exchange ideas and connect with them to keep up to date with what they’re working on as well.

We also got paired with a mentor, Marko, from NeoLook, a startup offering video services for neonatal and pediatric intensive care. His experience was very useful for us since his product had a similar infrastructure to ours, just in a different domain. His advice helped guide development and key outreach decisions.

At the time, CalvAlert was still in its early stages. We had a business plan and one pilot running in Cyprus to gather data for our MVP.

Through UtrechtInc, our main goals were to:

• Validate our business model plan
• Build a stronger Dutch network with startups and like-minded people
• Explore opportunities for a second pilot in the Netherlands
• Achieve small funding for CalvAlert expenses

Key Highlights

The program gave us a lot more than theory:

• We pitched at multiple community events and spoke directly with visitors during a testing grounds event
• We landed a second pilot program at Dairy Campus, part of Wageningen University — a huge milestone
• I met many entrepreneurial and tech-savvy people and stayed plugged into the Dutch startup ecosystem
• We secured €1,000 in funding through UU Playground
https://www.uu.nl/en/organisation/playground

Looking Back

The program

The UtrechtInc Student Validation Program was an amazing experience. I’d recommend it to anyone with a startup idea, even if it’s not fully developed. The business learning alone makes it worthwhile, and the networking is invaluable.

As for us, CalvAlert now has:

• Two pilot programs running (Cyprus and the Netherlands)
• A goal of starting a third
• An MVP under development aimed for the end of 2025
• A website and social presence at https://withlency.com/

My advice to others

The key takeaway isn’t just about entrepreneurial programs. It’s about engaging with events and meeting people. That’s where perspective, growth, and real opportunity come from.

In CS especially, it’s easy to isolate and think everything can be learned online. What you miss is lived experience and human connection. That can’t be Googled.

If you’re in Utrecht, check out:
https://utrechtinc.nl/
https://www.uu.nl/en/organisation/playground

Across the Netherlands:
https://yesdelft.com/
https://starthubwageningen.nl/

Events worth watching:
https://www.crossroads2025.nl/home
https://startlife.nl/

In the end, the real value isn’t just in building products — it’s in building the connections that shape who you become.