A small story about AI hype, office culture, and using a amazing advanced technology for something completely ridiculously and trivial.

One of those completely ordinary grey Tuesdays happened.

You know the kind.

You wake up.
You look outside.
The sky is grey.
You open your laptop.
The news feed is full of two things:

• companies rolling back remote work in the name of “culture” and “innovation”
• AI supposedly replacing half the workforce within the next five minutes.

At that exact moment I had to go to the office.

And I had a very practical question.

Where should I sit today?

Normally the answer is simple:

• sit where you always sit
• grab the nearest free desk
• or walk around awkwardly pretending to look for someone.

Instead, a slightly absurd idea appeared in my head:

What if an AI agent decided where I should sit every day?

Not randomly.

Not habitually.

But based on rules, fairness, social dynamics, and a little bit of chaos.

Using amazing Technology to solve a Ridiculous Problem

Right now we live in a time where AI is often presented as:

• the ultimate productivity tool
• the solution to every business problem
• the replacement for knowledge workers

Meanwhile companies want employees back in the office to “rebuild culture”.

So I thought:

What if I used AI to do something that actually contributes to culture?

Not automation.

Not efficiency.

Just something playful.

Something that makes people laugh a bit when they arrive.

Something that makes people talk.

The Idea: An AI Seating Agent

The idea became a small experiment.

I created an AI agent (LLM-based agent) that would recommend which desk I should sit at every day.

But it shouldn’t just be random.

The agent should consider things like:

• fairness
• seat quality
• colleague preferences
• social dynamics

And most importantly:

it should explain its reasoning.

This is actually one of the things modern LLM agents are very good at:

transparent reasoning (chain-of-thought style reasoning / explainability)

The agent would therefore act as:

• a decision system
• a game
• a social experiment

Version 1 – Just Rotation

The first version was extremely simple.

The agent just calculated a deterministic seat based on the date.

Why?

Because fairness requires some kind of baseline rule.

So the agent calculates Day Of Year (DOY).

Example:

4 March → Day 63 of the year

Then it maps the day to a seat number:

BaseSeat = ((DOY - 1) mod 12) + 1

This is just modular arithmetic (modulo distribution).

If there are 12 desks, the rotation will cycle through them across the year.

So every day starts with a base seat recommendation.

This is the deterministic baseline (deterministic rule system).

Version 2 – The Agent Becomes Opinionated

Rotation alone is boring.

So I added scoring rules (heuristic scoring model).

Each seat would receive a score based on different factors.

Example factors:

Rotation score

How close the seat is to the base rotation.

Window score

Some desks are simply better.

Window seats in our office:

1, 3, 7, 9, 11

Premium seats

Corner desks.

1 and 11

Colleague preferences

Some colleagues love specific desks.

For example:

• Henrik loves seat 11
• Rohan prefers 12
• Jens prefers 3
• Sus prefers 1

So if the agent gives someone their preferred seat, it increases something I called:

Team Harmony Score (social optimization heuristic).

Version 3 – Logging Everything

At this point the agent started to become more interesting.

Because it logs every decision.

Whenever I sit down I confirm with a small command:

4=ok

The agent logs:

Date	Person	Suggested	Actual

This creates a history dataset (interaction log).

From this data the agent can calculate different indicators.

Version 4 – Social Metrics

Now things started getting fun.

Instead of only optimizing seats, the agent started tracking social indicators.

For example:

Seat Coverage Score

How many different seats someone actually uses.

SCS = unique seats used / 12

This prevents people from claiming territory.

Window Hogging Index

Measures how often someone takes attractive window seats.

WHI = window seats last 10 days / 10

Corner Premium Index

Tracks usage of the best desks.

CPI = premium seats last 10 days / 10

Neighbor Disruption Score

This one was slightly more mischievous.

If you sit in the same area repeatedly, you might annoy the same colleagues.

So the agent calculates seat zones:

{seat-1, seat, seat+1}

If you sit in the same zone repeatedly, your Neighbor Disruption Score increases.

Version 5 – The Cake Algorithm

This is where things became slightly ridiculous.

The agent calculates an Irritation Risk Score.

IRS = 3*CPI + 2*WHI + NDS + (1 - SCS)

Which roughly means:

• hog premium seats
• sit near the same colleagues
• don’t rotate enough

…and your irritation score increases.

If the score becomes too high the agent suggests:

Cake Due

Meaning:

You should bring cake.

Or snacks.

Or coffee.

This introduces something I call:

Goodwill Balance (social credit / reciprocity metric)

Certain actions increase goodwill:

cake=ok
snacks=ok
coffee=ok

These restore the balance.

Version 6 – Gamification

At this point the experiment started drifting into game design territory.

Ideas started appearing:

• bribing a colleague for a seat
• coolness points
• department leaderboards
• wellbeing rewards
• team events

Imagine:

If the whole department participates, the system becomes a tiny social game.

For example:

• points for sitting on unpopular desks
• bonus points for coming early
• bonus points for sitting during quiet hours
• bonus points for helping someone else

This is essentially lightweight gamification (behavioral incentive design).

Version 7 – Sensor Integration

Then I had another thought.

Many modern offices already know which desks are occupied.

Desk booking systems.

Seat sensors.

Badge data.

Imagine feeding that data into the agent.

Now the system could detect:

• which desks are usually free
• peak hours
• collaboration patterns

Meaning the seat agent could become a real optimization system (agentic decision system).

Prompts vs Instructions vs Agents

Along the way I learned something interesting about working with LLMs.

There are actually several layers involved.

Prompt

A single instruction you send to the model.

Example:

“Recommend a desk for today.”

System instruction

A persistent rule set describing how the model should behave.

Example:

“You are DeskRota, an office seating agent.”

Agent

A system where the model:

• maintains memory
• logs actions
• applies rules
• evolves over time

This is what DeskRota became.

A small agent-based decision system.

Which Tools Would You Use for Something Like This?

One of the slightly amusing aspects of this little experiment is that it uses very powerful technology to solve a completely trivial problem.

And that’s actually part of the point.

Most people meet AI through grand narratives:

• enterprise transformation
• massive productivity gains
• autonomous systems
• replacing entire job categories

But the best way to understand these tools is often to play with small, harmless problems.

Like deciding where to sit in the office.

So if you look at something like the DeskRota example, it’s actually a nice mental model for understanding what different AI tools are good at.

Not academically.

But practically.

ChatGPT / OpenAI

In my case the entire experiment was built using the paid version of ChatGPT with a Custom GPT.

That means:

• I created a persistent system instruction (system prompt)
• The model keeps a memory of the conversation (session context)
• It behaves like a small agent with rules

This is probably the simplest way to experiment with AI agents today.

You don’t need infrastructure.

You don’t need APIs.

You don’t need code.

Just a good instruction.

And curiosity.

If you wanted to extend this in the OpenAI ecosystem you could imagine:

• OpenAI Assistants / Agents API
  (for building a persistent agent with structured memory)
• Function calling / tool use
  (for connecting the agent to systems like desk booking)
• RAG (Retrieval Augmented Generation)
  (for letting the agent read company policies or seating maps)

But for experimentation, a Custom GPT is perfectly sufficient.

Which is exactly what I used.

Microsoft AI Ecosystem

If you look at the same idea from the Microsoft ecosystem, different tools would play different roles.

Copilot Studio

Copilot Studio is essentially designed for building conversational agents (low-code AI agents).

A DeskRota agent could easily live here.

Typical uses would be:

• creating a chat-based office assistant
• integrating with Microsoft Teams
• connecting to Power Platform data
• retrieving desk availability from internal systems

In other words:

Copilot Studio is perfect when you want to turn an idea like this into a real workplace tool.

GitHub Copilot

GitHub Copilot is something very different.

It’s primarily a coding assistant (AI pair programmer).

So in the DeskRota example it would be useful if you wanted to:

• write the backend service
• build a seat allocation API
• connect to sensor systems
• integrate with desk booking systems

In short:

Copilot helps you build the system, not run it.

Copilot for Tasks / Automation

Another interesting direction would be task agents (AI task automation).

For example:

An agent that:

• checks desk availability
• assigns seats
• sends a Teams message
• updates a log

This is the kind of scenario where tools like Copilot for automation workflows or Power Automate with AI become useful.

Here the AI is not just answering questions.

It is triggering actions across systems.

Why Playing With Small Ideas Matters

The interesting thing about AI is that the learning curve is often backwards.

People think they need a big idea.

A big project.

A big transformation.

But in reality the best way to learn is to start with something slightly ridiculous.

Something small.

Something playful.

Because once you understand how these tools behave in a small system, you can suddenly see:

• where Copilot Studio fits
• where GitHub Copilot fits
• where automation agents make sense
• where LLM agents like ChatGPT are sufficient

And you begin to think differently.

Not just about what AI can replace.

But about what AI can make slightly more interesting.

Even something as simple as:

deciding where to sit on a grey Tuesday morning.

The Unexpected Insight

What started as a joke actually revealed something interesting.

We talk a lot about AI replacing workers.

But many of the things that make workplaces work are deeply human:

• humor
• fairness
• shared rituals
• small acts of generosity

Ironically, AI can help facilitate those things.

Not by replacing us.

But by creating small structures around social interaction.

The Final Agent

The current version of DeskRota now:

• calculates a daily seat
• logs every seating decision
• tracks multiple social indicators
• detects overuse of premium desks
• recommends social initiatives
• supports multiple participants
• evolves through prompts and rules

And most importantly:

It makes a completely ordinary office morning slightly more interesting.

Try It Yourself

If you want to try building your own seating agent, I’ve published the full instruction set here:

Copy it into any AI agent system and start experimenting.

Who knows.

Maybe the next time someone asks you:

“Where should I sit?”

The answer will be:

“Let’s ask the agent.”