Notion Developer Platform made me redesign my workflow
The future of Notion is not just pages and databases. It is workflows that people and agents can both understand.
Small disclaimer before I say anything else: I am a Notion Ambassador, so yes, I already care about Notion more than the average person.
But that is also why this hit me properly.
On the 13th of May, I went to the Notion Developer Platform Launch Watchparty in London. I expected new AI features, better integrations, and the usual product launch excitement. I did not expect to leave the broadcast rethinking how I structure my own workflow.
But that is what happened.
Notion has been shipping at a ridiculous pace recently. It honestly feels like there is a new feature every week, and at some point it becomes impossible to keep up with every release properly. Some updates are useful, some are exciting, and some slightly change the way you think about the product.
The Developer Platform felt like one of the bigger ones.
The first thing that clicked was syncing. External data flowing into Notion databases immediately made sense. It felt like the cleaner version of something teams have wanted for ages: scattered context finally coming together in one place.
Then they showed Workers, and that was cool.
Developers being able to run custom code on Notion’s infrastructure, sync data, trigger workflows, and build custom agent tools made Notion feel much more programmable than before.
But the moment that made my jaw drop was orchestration and external agents.
Claude, Codex, Decagon, internal company agents, Custom Agents, MCP connections, Workers, databases, permissions, and human review all sitting inside the same workspace.
That did not feel like “Notion has AI now.”
It felt like Notion becoming a coordination layer between people, tools, data, and agents.
And weirdly, the first thing it made me think was that my own Notion setup was not ready for this.
A lot of my workspace was designed for me.
It was not designed for agents.
Notion is changing who it is built for
There is a boring way to talk about the Developer Platform.
You can list the features: Workers, database sync, webhook triggers, custom agent tools, orchestration, external agents, a CLI, and deeper developer infrastructure.
All of that matters, but the bigger thing is the direction of travel.
Before this, Notion was already a great all-in-one workspace for knowledge management. Product people used it to organise roadmaps, specs, research, and decisions. Sales teams used it for notes, handoffs, customer context, and internal processes. Knowledge workers used it to build docs, wikis, task systems, personal dashboards, and shared operating systems.
That version of Notion was already powerful.
But the Developer Platform stretches the product into something different.
Notion is no longer just an all-in-one workspace for knowledge workers.
It is becoming an all-in-one productivity tool for builders in general.
That distinction matters.
Builders do not just need a place to write things down. They need systems that can connect data, run logic, trigger workflows, expose tools, coordinate agents, and turn context into action.
That is why the Developer Platform feels bigger than a feature launch.
Database sync brings in live context. Workers let developers write custom logic close to the workspace. Custom agent tools let agents do more than answer questions. External agents suggest Notion is not trying to be the only AI in the room.
It is trying to become the room.
Workers made Notion feel programmable
Workers were the first feature that really made me sit up.
Notion describes Workers as hosted custom code that can power database sync, custom agent tools, and webhook triggers without teams needing to run separate infrastructure.
That matters because real workflows do not live neatly inside one app.
They stretch across Slack, Linear, GitHub, Figma, email, calendars, CRMs, databases, docs, and a painful number of “just checking where this got to” messages. The dream has always been to make Notion the place where those threads come together, but the problem was that Notion was often strongest as the place where you organised the work, not always where the live work actually happened.
Workers start to close that gap.
If external data can sync into Notion, if custom tools can run from inside the workspace, and if agents can use those tools, then Notion starts becoming part of the workflow execution layer.
Notion is no longer only where you keep context.
It is where context can become action.
Custom Agents made this direction feel inevitable
The Developer Platform is not happening in isolation.
Earlier this year, Notion launched Custom Agents, and that already made the direction feel obvious. These are not just chatbots that answer questions about your workspace. They are closer to bounded teammates that can follow instructions, use workspace context, react to triggers, and connect to other tools.
Most productivity problems are not solved by asking one clever question.
They come from repeated operational drag: updates being rewritten, meeting notes becoming tasks, project context being re-explained, decisions getting buried, follow-ups depending on memory, and blockers only becoming visible once they have already slowed everything down.
None of that is the glamorous part of building, but it is often what decides whether a team actually moves well.
That is where agents start to make sense.
Not as magical replacements for people, but as workflow operators that handle the repetitive coordination layer around people while humans keep judgement, taste, context, and the final call.
Orchestration was the jaw-drop moment
Custom Agents made the direction feel inevitable, but orchestration made it feel much bigger.
The problem with agents is not just intelligence. It is coordination.
One agent might summarise a meeting, another might draft a Linear ticket, another might check a database, another might pull context from Slack, and another might review a document or touch code. On paper, that sounds useful. In reality, without a shared system around it, it becomes chaos quickly.
Someone still needs to know which source of truth the agent should trust, what it is allowed to change, when it should ask for approval, where the output should go, and how the team can understand what happened afterwards.
This is why Notion’s direction is interesting.
The workspace becomes the shared canvas. Humans can see the work, agents can access the context, tools can connect through MCP, Workers can run custom logic, databases can act as structured memory, and permissions can create boundaries.
That is much more interesting than a chatbot bolted onto a document editor.
It starts to look like an agent-native workflow system.
My workspace was not ready for this
This is where my brain immediately went to my own setup.
If agents are going to operate inside my workspace, then my workspace cannot just be a collection of pages that make sense to me at 2am.
It needs clearer databases, better statuses, stronger ownership, and fewer vague dumping grounds. It needs to become agent-readable.
I have used Notion for my personal life, W-15 Interactive, KCL Tech, Notion Ambassador stuff, my current job and the general chaos of trying to be a multidimensional builder without everything collapsing into twelve different tabs and three half-finished docs.
For a long time, I organised Notion around how I think and it made sense. Your workspace should reflect your brain.
But agents change the question.
It is no longer just whether I can understand a page later. It is whether an agent could understand what it means, what matters, what is blocked, who owns it, what should happen next, and what it is allowed to do.
That is a much higher bar.
This is already close to how I use Notion
Another disclaimer, because this part matters: I use paid Notion features in my own workflow. Custom Agents require Notion credits, AI Meeting Notes requires the Business Plan, and a lot of the newer Developer Platform features are aimed at Business and Enterprise workspaces.
So this is not me pretending every feature is instantly available to every single Notion user. It is me looking at the direction of the product and realising that my own workflow is already starting to move that way.
A simple example is how I use AI Meeting Notes and Custom Agents.
I’ll be walking home with my headphones on, with AI Meeting Notes open, basically throwing ideas at Notion for a new web app. I do not need to structure everything perfectly in the moment. I can just talk through the idea, the messy constraints, the rough feature list, the product thinking, the target users, the edge cases, and whatever else is floating around in my head.
When the meeting ends, Notion turns that into a searchable note with a summary and action items. That note can then live inside a specific database, instead of disappearing into the usual graveyard of random notes and half-formed ideas.
From there, a Custom Agent can pick it up and turn the mess into something more useful.
It can read the raw idea, pull in relevant context from my workspace, look at previous plans, check my resources database, use technical notes, reference product patterns, and then create a proper entry in my Plans database. Instead of a messy voice dump, I can end up with a project name, problem statement, target user, core features, MVP scope, suggested stack, data model, pages or routes, risks, open questions, and next steps.
That is already useful.
But the Developer Platform makes the next step much more interesting.
Once the plan exists, the Custom Agent does not have to stop at documentation. It can call tools. Notion MCP gives AI tools a way to connect with a Notion workspace, and Custom Agents can connect to external tools through MCP.
So the workflow starts to look different.
The idea starts as a voice note while I am walking. Notion turns it into a searchable meeting note. A Custom Agent turns that into a structured plan. Another agent or coding tool can then use that plan to start the project, create a repo, scaffold the app, push the first commit, and update the Notion plan with the repo link. Heck, you could also use workers and the CLI to deploy Version 0.
That changes the feeling of starting something.
Before, I would walk home, open my laptop, open the plan, and then start from zero. Now the ideal version is that I walk home, open my laptop, and the project already exists. I still need to clone the repo, run it locally, test it properly, make product decisions, fix the weird bits, and actually engineer the thing.
But the blank-page setup work is gone. The agent is not replacing the engineering work.
It is removing the cold start.
The next great Notion setup will be agent-readable
A lot of Notion culture has historically been aesthetic: Beautiful dashboards. Clean icons. Nice covers. Life OS templates. Second brain setups. Moodboard energy. I love that side of Notion.
But I think the next phase is going to be less about aesthetic systems and more about operational systems.
A good setup will need to answer different questions: Can a person understand this? Can an agent understand this? Is there a clear source of truth? Are decisions visible? Are tasks owned? Are statuses meaningful? Are permissions sensible?
That is the new standard.
The workspace cannot just look clean. It has to behave clean.
That changes how you design databases, name properties, structure projects, define ownership, track decisions, and separate reference material from action. It turns Notion from a personal organisation tool into something closer to workflow infrastructure.
And once you see that, you cannot really unsee it.
MCP makes this more powerful and more serious
MCP is one of those terms that sounds boring until you realise what it unlocks.
The Model Context Protocol gives agents a way to connect with external tools and services. In Notion’s case, MCP connections mean Custom Agents can interact with tools beyond the workspace, depending on how they are configured.
That is exciting because agents are not trapped inside one workspace.
But it is also exactly why trust becomes more serious.
Once an agent can touch external tools, the risk changes. A notes app being messy is annoying. An agent with access to external tools being messy can create actual damage.
This is why I do not buy the fantasy where everything becomes fully autonomous and we all relax while agents do our jobs perfectly. Real work is too context-heavy, too political, too ambiguous, and too full of edge cases.
The better future is supervised autonomy.
Some things should be automatic, some things should be suggested, some things should be drafted, some things should be reviewed, and some things should be blocked entirely.
That is how you make AI useful without making it terrifying.
What I changed in my own thinking
I am not pretending I have rebuilt my whole setup perfectly. I have not. But the mental model has changed. Before, I would ask where something should go. Now I am starting to ask what it should become.
A meeting note should become decisions, tasks, follow-ups, risks, and context. An event idea should become a pipeline with status, owner, venue, partners, sponsors, audience, assets, and next action. A Substack idea should become a thesis, research queue, examples, draft status, publishing plan, and distribution angle.
The same applies everywhere.
A partnership conversation should become relationship context, open loops, commitments, and follow-up dates. A product idea should become a problem, user, current behaviour, possible solution, risks, and acceptance criteria.
That is the redesign: making Notion more executable.
Because if the workspace is just a graveyard of information, agents will not save it. They will just help you bury things faster.
The reason I care about this is not because I want another excuse to rebuild my Notion setup for the 400th time (I probably will to be fair).
I care because this feels like a wider shift in how software is changing.
For a long time, software was mostly interface-first. You opened the app, navigated the UI, clicked the button, filled the form, moved the card, updated the field, and repeated the same patterns across every tool you used.
Now we are moving towards intent-first software: You describe the outcome. The system understands the context. It uses the right tools. It asks for approval when needed. It completes the low-risk parts. It leaves a trace of what happened.
That does not remove the need for interfaces. It changes what interfaces are for.
KCL Tech, the tech society at King’s that I lead, is a Notion for Startups partner. If you are building something, you can use our link to get six months of Notion Business and Notion AI for free.