A lot of AI advice still sounds like it was written for a demo.
Open a tool. Type a clever prompt. Get an answer. Save time.
That can help, but it’s not how most real business work feels.
Real work arrives messy. Someone asks for a client update in Slack. A follow-up is buried in a meeting note. A HubSpot change depends on a workflow, a list, a property and something that was agreed three weeks ago. A blog idea is sitting in Trello, but the source notes are in an old thread and the final draft needs to live in Google Docs.
That’s the gap we’ve been working on at CLCK.
We’ve written before about building an embedded AI assistant inside the business. We’ve also shared how we use Arlo and Hermes for our own marketing workflow. This piece is a little different.
This is more of a diary from the inside.
Not a product announcement. Not a promise that the robot runs the business. Not a shiny AI tools roundup.
Just what it actually looks like when an AI agent works close to the places where the work already happens.
The biggest shift isn’t speed. It’s context.
The obvious benefit of AI is that it can write, summarise, research and draft quickly.
That’s nice, but speed on its own isn’t enough.
If the assistant starts every task from zero, you still have to explain the business, the client, the workflow, the tone, the approval rules, the source documents and the thing that went wrong last time. At that point, you’re still doing a lot of the work. You’re just doing it in prompt form.
The real shift happens when the assistant can work from context.
For us, that means Arlo can help from the places where our work already lives:
- Slack and Zulip threads
- Trello cards
- Google Docs and Drive
- HubSpot context
- website content and code
- internal notes and workflows
- scheduled checks and recurring reviews
- previous decisions that are worth carrying forward
That doesn’t mean every tool is open for every task. Permissions matter. Scope matters. The point isn’t to give AI the keys to everything.
The point is simple: stop treating AI like a blank text box and start treating it like part of the operating layer.
A normal request is rarely just one task
Here’s a simple example.
Someone says, “We haven’t published a proper article for a few weeks. Review the Trello queue and suggest ideas.”
On the surface, that sounds like a content task.
In practice, it needs several small checks:
- What has been published recently?
- Which Trello cards are ideas, selected topics, drafts or already published?
- Is there a card that looks ready but has already been turned into something else?
- Is the topic still current?
- Does it match the broader CLCK positioning?
- Are there any source notes, voice notes or linked drafts?
- Should the next step be a draft, a website build, an email, or just a recommendation?
That’s where an embedded agent starts to feel different from a chatbot.
A chatbot can help brainstorm five article ideas.
An embedded agent can inspect the actual queue, check what is already live, notice that a topic overlaps with a previous article, and suggest the next safe step.
That last part matters: the next safe step.
Not the most impressive step. Not the biggest autonomous leap. The next step that moves the work forward without creating a mess.
We use parent and child workflows to keep work controlled
One pattern we now use a lot is a parent and child workflow.
The parent thread keeps the goal in view. It holds the strategy, the current state, the approval boundaries and the next decision.
A child task handles one bounded slice of the work.
For example, a child might:
- inspect a source document
- draft an article
- check a live page
- prepare a Trello update
- review a HubSpot setup
- test a staged website preview
- summarise a client workstream
The child comes back with a compact report. The parent checks it, catches anything that doesn’t fit, then decides what happens next.
This sounds slower than just telling the AI to “do everything”. In practice, it’s often faster because it reduces drift.
Long AI threads can lose the plot. They can over-focus on one detail, forget a boundary, or keep pushing ahead when the right answer is to stop and check.
A parent and child pattern gives us a control loop.
It also makes the work easier to review. Instead of a huge thread full of half-finished reasoning, we get smaller pieces of work with clear scope and evidence.
AI prepares. People approve.
This is one of the most important rules in our setup.
AI can prepare a lot of work.
It can draft an email. It can create a Google Doc. It can inspect a Trello card. It can check a website preview. It can pull together source notes. It can suggest the next action. It can create a first pass that a person can review.
But there are lines it shouldn’t cross without approval.
For us, those include:
- sending external emails
- publishing website changes
- posting on social channels
- changing client HubSpot portals
- making destructive changes
- restarting production systems
- touching sensitive data without a clear reason
- making commercial decisions
That’s not because we don’t trust AI at all.
It’s because trust needs shape.
A good assistant should know when to act, when to prepare, and when to ask for a decision.
If every tiny action needs approval, the system becomes annoying. If nothing needs approval, the system becomes risky.
The craft is in drawing the line properly.
The work still needs sources of truth
An embedded agent is only as good as the sources it can rely on.
If a business has three different places where the truth might live, the assistant will struggle in the same way a person would.
We’ve had to get clearer about this inside CLCK.
For content, Trello is the queue. Google Docs is the draft source of truth. The website repo is the build source. Zulip is where strategy and approvals happen.
For client work, the source might be a HubSpot record, a workstream note, a support ticket, a Google Doc, a time ledger or a Slack thread.
The exact tools matter less than the rule.
The assistant needs to know where to look first.
Without that, AI becomes another place where work gets copied, pasted and half-remembered.
With it, the assistant can recover context quickly and make better first-pass decisions.
The most valuable corrections become part of the system
One of the biggest lessons is that feedback shouldn’t disappear into a chat thread.
If I tell Arlo, “This writing is too stiff, make it warmer and simpler,” that shouldn’t just fix one paragraph. It should improve the next draft too.
If we discover that a workflow needs a stronger privacy check, that should become part of the workflow.
If a screenshot is technically safe but visually pointless, the process should learn that both safety and clarity matter.
That’s where durable instructions, skills, checklists and operating notes become important.
The goal isn’t for the assistant to remember every random comment forever. That would get noisy.
The goal is to keep the lessons that stop the same mistake happening again.
For a small team, that can make a big difference. You don’t want to keep re-explaining your tone, your approval rules, your CRM assumptions, your reporting format or your publishing process every time a new task starts.
The agent isn’t replacing the team. It’s reducing drag.
The best way I can describe Arlo’s role is this: it reduces the drag between knowing something should happen and getting a reviewed first pass in front of the right person.
That might mean:
- turning a messy idea into an article brief
- checking a client workstream before a reply is drafted
- preparing a time report from the live ledger
- reviewing a HubSpot setup against the agreed process
- finding the next article card in Trello
- drafting a client-friendly explanation from source notes
- checking whether a staged page is ready for review
- flagging that a task is risky and shouldn’t be rushed
None of that removes judgement from the business.
It gives the team more leverage around the judgement they already have.
That’s an important difference.
A lot of AI positioning still jumps straight to replacement. Replace the writer. Replace the salesperson. Replace the assistant. Replace the agency.
That’s not the version I’m most interested in.
The more practical opportunity is support.
Help the business remember. Help it prepare. Help it check. Help it keep moving when the work is spread across too many systems and too many small decisions.
The messy parts are where the real design work lives
There are still rough edges.
Context can get stale. A card can be left in the wrong Trello list. A previous article can overlap with a new idea. A source can be missing. A workflow can be too broad. A tool can fail. A model can sound too dry if the voice rules aren’t strong enough.
That’s not a reason to give up.
It’s a reason to design the operating layer properly.
In our experience, the most important questions aren’t “which AI tool should we buy?”
They are questions like:
- Where does the work begin?
- Where is the source of truth?
- What can the agent read?
- What can it draft?
- What can it change?
- What needs approval?
- How does it report back?
- How do corrections get saved?
- How do we know the work is actually done?
Those questions aren’t as exciting as a demo video.
But they are the difference between AI as a toy and AI as part of the business.
What I’d copy first
If you’re trying to use AI more seriously inside your business, I wouldn’t start by trying to automate everything.
I’d start with one workflow that’s already painful.
Choose something that’s:
- repeated often
- spread across a few tools
- context-heavy
- low-risk enough to draft before approval
- annoying enough that the team feels it
- clear enough that success can be checked
Good starting points might be sales call prep, follow-up drafting, content briefing, CRM review, support triage, weekly reporting or proposal preparation.
Then design the workflow around the assistant.
Give it a source of truth. Give it a clear output. Give it boundaries. Give it a review step. Give it a way to report what it checked and what it changed.
Do that well once, then expand.
That’s the part that feels most promising to me.
Not a magic prompt. Not a giant AI transformation project. Not a risky leap into full autonomy.
A practical operating layer that helps a small team move from scattered context to reviewed next steps faster.
That’s what running an embedded AI agent actually looks like from the inside.
Less dramatic than the demos.
Much more valuable in the day to day.
If you want help working out where an embedded AI workflow could safely start in your business, book a strategy session here: https://www.clck.com.au/book-a-strategy-session/