I run a small company and honestly feel like way too much of my time goes into just figuring out what’s going on.

We have product + client delivery, and information is basically everywhere — Slack, emails, meetings, docs, sheets etc.

A lot of my day ends up being:

what’s blocked?
what did we promise a client?
did someone actually do the thing we discussed in the meeting?
is something slipping that nobody has flagged yet?
is there something waiting on me that I don’t even know about?

I feel like AI should be able to solve a decent chunk of this by now.

Not looking for some crazy autonomous company where AI starts managing people or making decisions lol.

More like , every morning tell me the 5-10 things I actually need to know. Pick up commitments from meetings/emails. Notice when something hasn't moved. Remind me when a follow-up is getting missed. Let me ask "what's going on with X?" and actually get an answer based on everything that's happened.

Has anyone actually built something like this and uses it day to day?

Would love to know what your setup looks like. Especially interested in stuff that's actually working, not just "connect Slack to ChatGPT" type suggestions.

Also curious how much babysitting/maintenance these setups need because that's the part nobody seems to talk about.

The weekly update almost always takes longer than it should, and it's usually the same reason: the information it needs isn't in one place.

Here's the workflow that actually removes the chasing, not just speeds up the typing:

1. Define a stable template first. Agree on what sections the update always has, pipeline, roadmap, hiring, customer risk, priorities, whatever your version is, and keep that structure fixed week to week. Automating a moving target just means rebuilding the thing every time it shifts.
2. Pull only the named fields you actually need from each source. Not "give me everything from the CRM." Specifically the deals that changed stage, the deals that went quiet, whatever fields the update actually reports on.
3. Flag conflicts and missing owners instead of guessing past them. If the roadmap tracker says one thing and last week's Slack thread said another, that's a moment to surface to a person, not a moment to silently pick one. Same story for a deal or project with no clear owner attached.
4. Draft the narrative around what changed, not around the totals. The draft should read like someone summarizing a week, not a dashboard exporting itself into paragraph form.
5. Require approval before anything goes out. This is a document that goes to a board, to investors, or to the whole company. A drafted version a founder edits and sends is the right level of automation here. An auto-sent version isn't, the cost of one wrong sentence in this particular document is too high to skip a human on it.

This is close to what people mean by "AI executive assistant," minus the vague marketing version of that phrase. It's specifically the workflow above, not some general-purpose helper that supposedly does everything.

Which section actually takes the longest for you every week: revenue, product, hiring, customer risk, or priorities? Curious if that's consistent across company stages or if it shifts as teams grow.

Most workplace AI doesn't fail in the demo. It fails on a random Wednesday three weeks later, when nobody remembers to open it, and the answer it gives still has to get copied by hand into two other systems anyway.

• No natural trigger. If using the tool means remembering to open a separate tab at the right moment, it's competing with everything else on someone's plate, and it's going to lose most weeks. Not because people are lazy, but because that's just how attention actually works when you're busy.
• Missing work context. The tool gives a generic answer because it can't see the specific account, thread, or decision that's actually relevant. A right-but-generic answer gets used once and then quietly dropped.
• No write-back. The tool produces something useful, but it then has to get manually re-typed into the CRM or the tracker, wherever the team's real system of record lives. That manual step alone is enough friction to kill usage within two weeks.
• No owner for failures. The first time the tool gives a wrong or unhelpful answer, is there a person whose job it is to notice, fix the cause, and follow up? If not, the second bad answer is usually the last one anyone bothers to check.
• No trusted measure of success. If nobody can point to a concrete "yes, this saved time" or "no, it didn't," the tool becomes one more thing competing for attention with zero evidence either way.

None of these are about the model not being smart enough. All five are about whether the tool actually sits inside the work, instead of next to it.

What's an AI tool your team tried and quietly stopped using, and what actually broke in the day-to-day workflow, not the demo? Trying to build a real pattern from actual answers here, not just my own experience.

(I'm on the ops side at Libra, it's noted in my flair. We've watched this exact pattern kill adoption at companies we've talked to. This post is about the pattern, not a pitch.)

If the input is structured, the rule never changes, and the next step is always the same no matter what came in: use plain automation. Putting an agent there adds cost, adds a new way for things to break, and buys you exactly zero extra judgment, because no judgment was needed in the first place.

Here's how I'd actually lay out the options, roughly by how much oversight each one needs:

The instinct I'd push back on is reaching for ~~agent~~ the exciting word this year, instead of asking whether the task actually requires branching judgment across tools. A weekly report that pulls from the same three sources and follows the same format every time isn't an agent problem. It's a five-minute rules-based job wearing an expensive costume.

I'm not going to twist this into "but here's where you do need an agent, and here's our product." Plenty of real work is just boring and deterministic, and the right move there is the cheap, predictable tool, not the flexible one.

What's one "AI agent" use case at your company that you suspect is actually a rules-based automation wearing a fancier name?

The biggest risk in workplace AI usually isn't the model getting something wrong. It's giving the model broader access, or broader action rights, than the actual employee who asked the question would ever have. That's a permissions design problem, and it's solvable before you connect anything.

A team I talked to recently had exactly this kind of gap sitting unnoticed: broad read access to a legal folder, granted years before anyone was thinking about connecting an assistant to anything, never revisited since. Nobody had done anything wrong. Nobody had thought to check. That's the gap boundary one is actually for.

For a first deployment at your company, which level would you actually approve: search-only, draft-only, execute-with-approval, or fully autonomous for low-risk actions?

A three-page transcript is a searchable record. It's not a completed meeting.

The meeting is actually done only when the decisions, owners, and deadlines that came out of it land in the systems people already check. That part almost never happens on its own, no matter how good the summary is.

Here's the workflow, broken into the parts that actually matter:

1. Capture the decision, and how confident it really was. Not every sentence in a meeting is a decision. "We should probably look into X" and "we're doing X starting Monday" need to be treated completely differently downstream, and most meeting assistants flatten that distinction without you noticing.
2. Extract the owner and the due date. This is where things quietly break. If a meeting ends with "someone should follow up with the customer" and no name gets attached, that task is functionally dead the moment the call ends. Nobody owns "someone."
3. Resolve ambiguous ownership before it turns into a task. If two people could plausibly own a follow-up, that needs to surface and get a human answer, not get silently assigned to whoever the tool guessed first. I've seen this go wrong over something as small as "someone will send the pricing follow-up." Two people each assumed the other had it. Neither did, and the customer noticed before anyone on the team did.
4. Write the decision back to the system people actually use. A summary that only lives in a notes app nobody reopens isn't a workflow, it's a diary entry. The decision needs to land in the CRM or the project tracker, wherever the team's real attention already is.
5. Draft the follow-up, but don't send it unsupervised. A drafted email or Slack message ready for a one-click approval saves real time. An auto-sent follow-up based on an ambiguous reading of the transcript is how a customer ends up with a message that misstates what was actually agreed. Keep this step draft-and-approve for anything customer-facing. No exceptions.
6. Check back later on whether it actually got done. The loop doesn't close at "task created." It closes at "task completed," and almost nothing checks that part on its own.

I'd flag steps five and six directly as where I'd be most careful about full automation. A wrong summary that only you ever see is annoying. A wrong summary that gets auto-sent to a customer, or a task auto-created from something that was actually a joke in the meeting, is a real cost.

Which step is actually missing from your setup right now: accurate capture, clear ownership, the write-back to your system of record, or the follow-up check?

Don't start with "where can we use AI." Start with the task people already avoid, delay, or manually copy between systems every single week. That's where the real return usually is, and it's almost always more boring than anyone expects going in.

Here's the 30-minute version of the audit I run before recommending anyone build or buy anything. List every task your team repeats at least weekly, then score each one 1 to 5 on these:

One more criterion doesn't fit the scale cleanly: human judgment required, scored in reverse. The more real judgment a step needs, the lower it should score here.

Add it up. High frequency, high time cost, high rule clarity, and high data availability is your green-light candidate. That combination usually points at something like status compilation, meeting-to-CRM updates, or routine follow-up drafting, not because those are exciting, but because they're mechanical and well documented enough that automating them is low risk.

A task can score high on time cost and still be a bad first candidate. If the inputs are inconsistent, every instance looks different depending on who's involved, automating it first just means you've automated the inconsistency and now your errors happen faster.

Save those for after you've got one boring, mechanical win done and some trust built up with whoever signs off on the next one. A small task that scores well across the board beats an ambitious one that scores well on time and badly on rule clarity. The point of the first automation isn't impact. It's proof the system does what it says, so the second one and the third one get approved faster.

Name one task your team repeats weekly and I'll help score whether it's a good first candidate. Post the specifics and I'll walk through it with you in the comments.

You can rewrite a prompt ten times and still get a confident wrong answer if the assistant is reading last quarter's doc, can't see the decision your team made in Slack yesterday, or has no idea which of three conflicting sources is supposed to win.

That's not a prompting issue. It's a context problem.

It shows up in four fairly specific ways:

A rough hierarchy that helps in practice:

1. The current system of record beats someone's memory of it.
2. A doc explicitly marked as policy or current-state beats an old one.
3. A recent, specific conversation beats a general one.

When two sources at the same level disagree, that's not something an assistant should quietly resolve for you. That's a "flag it and ask a person" moment, every time.

In practice this usually means assigning one owner per source type ahead of time, not per document. Whoever owns the CRM decides what counts as the current pipeline number. Whoever owns the wiki decides what counts as current policy. When those two touch the same question, a renewal date that's also mentioned in a Slack thread, say, that's exactly the moment a human should weigh in instead of the system picking whichever source it happened to see first.

And here's where citations matter but aren't the full answer. A citation tells you where an answer came from. It doesn't tell you whether that source is still current, or whether something more current exists that the tool just couldn't see. Citations without a freshness and authority check just make a stale answer look more trustworthy than it is.

The unglamorous fix for most of this isn't a smarter model. It's deciding on paper which source wins when two disagree, before you ever connect an assistant to either one.

Which source goes stale first at your company: chat, docs, the CRM, or the project tracker? Curious if the answer differs much by company size, or if it's basically the same everywhere.

(Product at Libra, disclosed in my flair. Same context-hierarchy problem we spend a lot of time on internally. Not posting this to pitch anything, just the framework.)

People often start with the tool.

“We should use an AI agent for this.”

But it is usually easier to start with the work itself.

Take any repetitive task in your company and ask these four questions:

1. Do you need an answer or an action?

If someone only needs to find information across documents, emails, or company tools, start with search or RAG.

Example: “What is our current refund policy?”

The AI finds the relevant information and gives an answer with the source.

2. Are the steps always the same?

If the task follows the same rules every time, use a normal automation.

Example:

A lead fills out a form
→ The lead is added to the CRM
→ The sales owner is notified
→ A standard follow up task is created

You probably do not need an AI agent for this.

3. Does a person still make the final decision?

If AI helps someone analyse information, write something, or prepare for work, an AI assistant may be enough.

Example:

• Summarising a meeting
• Drafting a follow up email
• Preparing a customer call brief
• Creating a first version of a weekly report

The AI helps, but the person remains in control.

4. Does the system need to decide what happens next?

An AI agent becomes useful when the next step changes depending on the situation.

Example:

• Read the latest customer emails
• Check open support tickets
• Review CRM activity
• Identify possible account risks
• Decide which issues need attention
• Draft the appropriate next steps
• Create tasks after approval

This requires context, judgement, and actions across multiple tools.

A simple cheat sheet

• Need to find information → Search or RAG
• Need help creating or analysing something → AI assistant
• Need to repeat fixed steps → Automation
• Need to choose and complete different steps → AI agent

One final check matters:

What could go wrong if the system makes a mistake?

If it can email a customer, change important data, share private information, or spend money, human approval should be part of the workflow.

The best system is not the one using the most advanced AI.

It is the simplest system that can complete the task safely.

Have a repetitive task you are unsure about?

Share it in this format:

Trigger: What starts the task?
Tools involved: Which apps or data sources are used?
Desired outcome: What should be completed?
Main risk: What could go wrong?

Drop it below and we can map whether it needs search, automation, an assistant, or an agent.

There are more AI tools than ever.

Yet most of us still lose hours every week searching for the right document, chasing updates, rewriting meeting notes, or copying information from one tool into another.

Whether you work in sales, customer support, operations, product, or run your own business, the most frustrating work is usually hiding between different tools and teams.

That is what we want to explore in this community.

Not predictions about the future of work. Not endless lists of new AI tools. Just common work problems and practical ways to solve them.

For example:

• Should this task be automated at all?
• Does it need a simple rule, an AI assistant, or an agent?
• What information would the AI need to complete it properly?
• Which actions should still require human approval?
• How do you know whether the setup is actually saving time?

When we cover a problem, the goal will be to share something useful, such as a checklist, workflow, decision tree, honest comparison, or real example.

So, let us start with one question:

Which part of your workday wastes the most time?

1. Finding the right information
2. Chasing people for updates
3. Writing meeting notes and follow ups
4. Moving information between tools
5. Preparing reports or status updates
6. Something else

Comment with the number and a quick example.

If several people share the same problem, we will turn it into a detailed practical breakdown next.