There’s a particular kind of workday where you technically get a lot done and somehow finish with the feeling that you accomplished absolutely nothing.

You answered twelve emails. You copied numbers from one place into another. You turned meeting notes into action items. You checked whether three people had replied. You renamed a file, updated a status, summarized a thread, found a document someone could have found themselves, and sent another “just following up on this” message.

Congratulations. Your entire afternoon has been eaten by tiny administrative creatures.

We’ve spent around six years working around APIs and software tools, and this category of work is surprisingly persistent. Companies keep adding productivity apps, yet people still spend ridiculous amounts of time moving information between them.

Microsoft’s 2023 Work Trend Index found that the average employee in Microsoft 365 spent 57% of their time communicating through meetings, email, and chat, compared with 43% creating in documents, spreadsheets, and presentations. Another 62% said they spent too much time searching for information. Microsoft’s Work Trend Index research

AI assistants offer an interesting way out because large language models are good at handling the messy middle between rigid software systems: reading unstructured information, figuring out what it means, generating the next useful output, and deciding which tool should handle it.

The trick is giving them the right jobs.

Busywork usually leaves the same fingerprints

Busywork can look wildly different between companies.

For a sales team, it might be updating CRM records after calls. A project manager may spend an hour turning Slack conversations into tasks. Someone in customer support keeps rewriting variations of the same answer. An operations team checks three dashboards every morning before building a fourth spreadsheet summarizing them.

Underneath, many of these jobs share a handful of patterns.

The same information keeps getting rewritten

Take this sequence:

A customer sends an email.

Someone summarizes it for Slack.

Another person creates a ticket.

The ticket becomes a status update.

The status update gets shortened for a weekly report.

Five pieces of text have now been created from essentially the same information.

An AI assistant can read the original input and create several structured versions of it: a short summary, ticket description, category, suggested priority, and draft response.

That is exactly the kind of language transformation LLMs handle well.

Someone keeps looking for information that already exists

“Where’s the newest pricing document?”

“Did we decide anything about the onboarding flow?”

“What happened with that customer?”

“Which campaign performed best last month?”

The answer may already live somewhere in your stack. Finding it becomes another job.

An assistant connected to approved knowledge sources can retrieve the relevant information, summarize it, and present the useful part instead of making someone perform another archaeological dig through folders and message history.

Tiny decisions repeat all day

Some workplace decisions barely feel like decisions:

• Which category does this ticket belong to?
• Does this message need an answer?
• Is this lead worth routing to sales?
• Which project does this note belong to?
• What priority should this task receive?
• Does this document require another review?

These are particularly interesting automation targets because the input is often messy enough that traditional rule-based software needs an increasingly ugly collection of conditions.

An LLM can classify that same information semantically.

The next step is obvious, but somebody still has to do it

A meeting ends, so action items need to be created.

A customer hasn’t answered, so a follow-up is due.

A report arrives, so somebody needs to summarize the changes.

A support request contains a billing issue, so it needs to reach billing.

A task is completed, so its stakeholders need an update.

Each action takes a minute or two. Multiply that across a team and across an entire year and the “little stuff” stops being little.

What should your AI assistant hunt first?

This is where AI productivity projects often become unnecessarily ambitious.

You don’t need an autonomous digital employee running half the company on day one.

A much better starting point is identifying tasks with three characteristics:

1. They happen frequently.
2. The expected result is reasonably predictable.
3. Fixing the occasional bad result is cheap.

That gives us a practical hunting list.

Workflow	What the assistant can handle	Human involvement
Inbox triage	Categorize, summarize, detect urgency	Review unusual/high-risk messages
Meeting follow-up	Extract decisions and action items	Confirm assignments or deadlines
Internal search	Find and summarize relevant information	Verify decisions based on sensitive data
Routine reporting	Turn structured results into readable updates	Review important conclusions
Customer support	Suggest replies and retrieve known answers	Escalate sensitive/complex cases
CRM maintenance	Extract names, companies, intents, next steps	Review ambiguous records
Task organization	Turn notes/messages into structured tasks	Approve priorities when needed
Document processing	Classify, extract, summarize	Verify critical fields
Follow-ups	Draft or trigger routine reminders	Keep approval for consequential communication

There is already solid evidence that this kind of assistance can improve real workplace output.

A large field study by Erik Brynjolfsson, Danielle Li, and Lindsey Raymond examined more than 5,000 customer support agents using a generative AI assistant. Productivity, measured as issues resolved per hour, increased by roughly 14% on average, with much larger improvements among less experienced workers. Read the NBER study, Generative AI at Work

That result is interesting for another reason: AI wasn’t equally useful to everyone.

Less experienced workers gained much more.

An assistant can act as a lightweight distribution layer for knowledge that otherwise sits inside the heads of experienced employees: common responses, preferred wording, troubleshooting patterns, process knowledge, and standard operating decisions.

Instead of asking Sarah from operations the same question for the 47th time, perhaps the assistant gets to enjoy that privilege.

A useful assistant has four jobs

Once you strip away the futuristic language around AI agents, a practical assistant usually follows a fairly understandable loop.

1. Understand what happened

First, something enters the workflow:

• an email;
• customer message;
• document;
• calendar event;
• form submission;
• support ticket;
• meeting transcript;
• database update;
• user request.

The model needs to interpret that input.

For example, imagine receiving this customer message:

We upgraded last week but our account still shows the old limits. Could someone check this? We need the extra capacity before our campaign starts tomorrow.

An assistant might extract:

• Intent: subscription/account issue
• Urgency: high
• Reason: campaign deadline tomorrow
• Required action: verify plan status
• Suggested department: billing/account support
• Reply needed: yes

That small interpretation step is what makes an LLM-based workflow more flexible than a pile of keyword rules.

2. Decide what should happen next

Next comes routing.

The assistant may decide to:

• retrieve account information;
• search documentation;
• create a task;
• request approval;
• draft a response;
• call another internal tool;
• escalate the case.

This is where an assistant starts becoming more useful than a standalone chatbot.

Chatting is one interface.

Work happens when the model can interact with the systems where your work lives.

3. Perform the allowed action

Suppose your application exposes functions such as:

search_customer()
create_ticket()
get_order_status()
create_task()
search_internal_docs()
draft_email()

The model can select the appropriate function based on the situation.

Your application still controls what each function actually does. That matters.

Giving a model access to a search_customer() tool can be fairly low risk.

Giving it unrestricted access to refund_every_customer() would produce a much more exciting afternoon.

Good assistant design uses narrow tools with clear permissions.

4. Check the result

Automation should include some idea of success.

Did the ticket actually get created?

Did the database return a customer?

Was the requested document found?

Did a tool fail?

Does the output meet the format your application expects?

For high-volume workflows, you can also log results and periodically review them for recurring mistakes.

That creates something far more useful than “we added AI.”

You get an observable workflow that can improve.

AI can also create brand-new busywork

There is an awkward possibility worth discussing.

You deploy an AI assistant to save time.

Now employees spend their time:

• correcting its summaries;
• checking whether it hallucinated facts;
• rewriting strange emails;
• retrying failed automations;
• explaining missing context;
• approving things they previously could have completed themselves.

Your productivity assistant has successfully invented another productivity task.

This is why we wouldn’t measure success by prompt volume, number of AI features launched, or how often employees open an assistant.

Measure the workflow.

If invoice processing previously required 14 minutes of human attention and now requires 4, you have something useful.

If it still requires 14 minutes plus an AI subscription, the experiment has given you an answer too.

The latest workplace data reflects this bigger distinction. Microsoft’s 2026 Work Trend Index, based on a survey of 20,000 AI-using knowledge workers across 10 countries, found that 66% said AI allowed them to spend more time on high-value work. Among more advanced users, AI agents increasingly appear inside multi-step workflows instead of remaining isolated chat tools. See Microsoft’s 2026 Work Trend Index

The same report found organizational conditions such as management support, culture, and working practices were much more strongly associated with reported AI impact than individual enthusiasm alone.

In plain English: handing everybody access to an AI model and hoping productivity happens is a pretty weak implementation strategy.

Where classic automation still wins

LLMs don’t need to touch every repetitive task.

If your rule can be expressed cleanly as:

IF invoice_status = overdue
AND days_overdue > 7
THEN send_reminder

regular automation is perfect.

It is fast, cheap, predictable, and easy to test.

AI becomes more interesting once interpretation enters the picture.

Imagine the rule instead sounds like:

Check the customer’s recent communication, determine whether they appear to be disputing the invoice or simply forgot about it, and choose an appropriate follow-up.

Now we have messy language and contextual judgment.

That’s LLM territory.

A good productivity stack can use both approaches.

Traditional automation handles deterministic steps.

AI handles fuzzy input, classification, summarization, extraction, generation, and decisions within carefully defined boundaries.

Then regular software handles the final action wherever possible.

That combination tends to be much easier to control than asking an AI model to improvise the whole process from beginning to end.

Give your assistant a brain through LLMAPI

If you’re building the assistant yourself, the language model becomes one layer of a larger system.

This is where LLMAPI can fit.

LLMAPI exposes familiar interfaces for working with language models, including an OpenAI-compatible Chat Completions endpoint and a Responses API-compatible endpoint. The Responses interface can accept tool definitions where supported by the selected model and API mode. See the LLMAPI Responses API documentation

A simplified assistant architecture might contain:

1. Your interface
   A dashboard, internal app, chatbot, browser tool, support portal, or background workflow.
2. Context
   The information the assistant needs for the current task.
3. LLMAPI
   Your application sends the model instructions and relevant context through the appropriate endpoint.
4. Tools
   Functions your application exposes for searching, retrieving, creating, updating, or triggering actions.
5. Your existing software
   CRM, database, project manager, documentation system, support platform, or another internal service.
6. Validation
   Your application checks outputs, permissions, tool results, and required approvals.

That architecture keeps the LLM where it is useful: interpreting language and choosing appropriate actions.

You can also choose the API style that fits the application

For conversational integrations, LLMAPI provides the OpenAI-compatible:

POST /v1/chat/completions

For applications using the Responses protocol:

POST /v1/responses

The current LLMAPI documentation also describes support for Anthropic Messages and Gemini-native calls through the appropriate API-key group, giving developers several protocol options within the same broader gateway. Check the LLMAPI getting-started guide

That can become useful as your assistant grows.

Maybe a lightweight classification task doesn’t need the same model you use for a complex research workflow. Maybe one workflow benefits from stronger reasoning while another needs speed and low cost.

Treating the model as a replaceable part of the architecture gives you more room to make those decisions later.

One assistant can have several levels of freedom

“AI assistant” can describe wildly different systems, so we like thinking about autonomy as a sliding scale.

Level 1: Suggest

The assistant does the thinking and leaves the action to you.

Example:

This email appears to be a refund request. Here is a suggested reply.

Very safe. Very easy to deploy.

Level 2: Prepare

The assistant creates everything required for an action but waits for approval.

Example:

I prepared a refund ticket with the customer’s order details. Approve?

This can remove most of the repetitive work while leaving consequential decisions with a person.

Level 3: Act inside rules

The assistant completes approved low-risk actions automatically.

Example:

I categorized 42 incoming requests and routed 37. Five ambiguous cases were sent for review.

Now we start getting meaningful automation.

Level 4: Run a workflow

The assistant handles several connected steps.

For example:

1. Read a support request.
2. Identify the customer.
3. Search relevant account data.
4. Retrieve internal documentation.
5. Determine the likely solution.
6. Draft a response.
7. Send straightforward cases.
8. Escalate unusual ones.

At this point, you’re approaching agentic workflow territory.

And this is where guardrails become increasingly important.

The boring tasks are also the safest place to learn

There is a very good reason to start your assistant with dull work.

AI capability is uneven.

A field experiment involving 758 Boston Consulting Group consultants demonstrated this particularly well. On tasks that were within GPT-4’s capabilities, consultants using AI worked more than 25% faster, completed more than 12% additional tasks, and produced substantially better work.

Researchers then gave participants a task deliberately positioned outside the model’s capability frontier.

The consultants using AI were 19 percentage points less likely to reach the correct answer. Read the published Organization Science study

The researchers call this the “jagged technological frontier.”

AI can perform brilliantly on one task and stumble on another that appears surprisingly similar.

That should influence what we delegate.

Great early candidates

Look for work where:

• mistakes can be reversed;
• results are easy to inspect;
• ground truth exists somewhere;
• actions have limited consequences;
• the task happens frequently enough to matter.

Examples include tagging, summarization, extraction, draft creation, document retrieval, formatting, and internal routing.

Add more supervision when consequences grow

Be much more careful with workflows involving:

• payments;
• contracts;
• hiring;
• medical information;
• legal decisions;
• security permissions;
• financial recommendations;
• irreversible account changes;
• sensitive external communication.

An assistant can still help with parts of these processes. Human approval, validation, audit logs, deterministic business rules, and narrow permissions become much more important.

The goal is productive delegation rather than maximum autonomy.

Try the “annoyance audit”

If you’re wondering where an AI assistant could help your own workflow, skip the grand AI transformation meeting for a moment.

For one week, write down every task that makes you think:

Ugh, this again.

Seriously.

Those moments are useful data.

At the end of the week, give each task four scores from 1 to 5:

Question	1	5
How often does it happen?	Rarely	Constantly
How repetitive is the outcome?	Completely different each time	Highly predictable
How much judgment does it require?	Expert judgment	Very little
How costly is a mistake?	Very costly	Easy to fix

Tasks with high frequency, high repetition, low judgment requirements, and cheap mistakes move to the front of the queue.

Suppose you find this:

“Every Friday I read five project channels, find what changed, and turn it into a status report.”

That is a lovely assistant job.

The workflow already has:

• identifiable sources;
• a repeated schedule;
• a predictable output;
• low-cost review;
• obvious success criteria.

You can build and evaluate that.

Then move on to the next annoying thing.

Productivity comes from removing steps

One of the easiest mistakes with AI is using it to make an existing step slightly faster.

Imagine your current process looks like this:

1. Export data from Tool A.
2. Paste it into a spreadsheet.
3. Clean the columns.
4. Upload the spreadsheet to Tool B.
5. Write a summary.
6. Send the summary to Slack.

You could add AI at step five and celebrate because summaries now take 30 seconds.

Or you could examine the workflow and discover that steps one through four can disappear too.

A properly integrated assistant might retrieve the data directly, identify relevant changes, generate the report, and prepare the final update.

The important productivity question becomes:

How many human interactions can we remove from this workflow while preserving the quality we actually need?

That is a much stronger metric than “How many tasks can AI do?”

Sometimes the best improvement is a faster task.

Sometimes an entire task can disappear.

Those are the wins worth chasing.

Your productivity stack already has enough apps

Most people probably don’t wake up hoping to add another dashboard to their morning routine.

Your calendar already has your meetings.

Your CRM has customers.

Your project manager has tasks.

Your inbox has messages.

Your documentation platform has company knowledge.

Your database has records.

The interesting role for an AI assistant is the connective layer between them: interpreting messy inputs, retrieving what matters, preparing actions, and moving routine work forward with fewer manual handoffs.

LLMAPI gives developers a way to place language models inside that layer using familiar API protocols and tool-capable model interfaces. The rest comes down to workflow design.

Start with one recurring annoyance.

Give the assistant enough access to solve it safely.

Measure whether human attention actually went down.

Then let it hunt for the next one.

Because the nicest productivity feature we can think of is opening your task list and discovering that some of the boring stuff already took care of itself.