Our agent, nicknamed “Owl”, has already become a documentation champ. I didn’t expect this use case to be the first win. It’s almost fully removed the annoying/cumbersome (but important) task of capturing decisions in our Confluence wiki. It jotted down some decisions on IEEPA tariff refunds / Section 122 tariff changes, worked up a page about an expensive component risk buy we made & drafted several internal docs on 3PL workflows. Combined, I’d estimate that saved 4-5 hours of work.

The Claw framework is hyped, maybe overhyped; but with companies like NVIDIA launching their own fork, Nemoclaw, I believe it has already made a permanent mark. Anthropic & OpenAI have started to build persistent memory & remote-first features into their own products.

My thesis going in was that an agent can collect our team’s own institutional knowledge. It will become a compounding knowledge base that can be easily searched. And it will capture key decisions and be an automated early signal on news in our specific supply chain (electronics). There’s so many directions we could take this - but next on the roadmap is moving toward establishing the concept of “advisory councils” for the team - this could really widen our small team’s reach to draw on simulated “expert” advice for our key issues.

Owl is purposefully limited in its access to internal systems. This is a trial and cannot access any PII or sensitive IP.

A few quick notes about the agent’s access:

• it has its own email address, google drive & calendar API integration

• it has access to read/write from confluence

• interfacing with the agent happens on slack

  • only the operations team has access / in specific channels

• it has access to crawl the internet.

Owl writes everything down in markdown format and saves it, making querying down the line easy. It should hopefully function like a second brain.

For now the use case of having institutional memory is not delivering. Its knowledge of us is thin. I suspect investing in building out a repeatable process for capturing context will be key to making it useful. We will be looking into creating an internal CRM (of our partners & actions that we’ve taken), automating meeting note intake, slack summaries & weekly status updates.

I’m excited to see where this heads. Stay tuned for more updates.

Over the past year, developers have been working with a new kind of AI tool. Persistent agents that live in their codebase, remember context across sessions, run tasks on a schedule, and accumulate knowledge in plain text files. Tools like Claude Code, OpenAI Codex, and a growing ecosystem of open-source agent frameworks.

These tools work differently from ChatGPT. You configure an agent with a workspace: a folder of markdown files that describe who it is, what it knows, how it should behave, and what tools it has access to. The agent reads those files every time it wakes up. It writes new files as it learns things. Over time, the workspace becomes the agent’s institutional memory.

The engineering teams using these tools are seeing something interesting. The value is in the accumulation. An agent that’s been working with your codebase for three months knows where the edge cases are, remembers the decisions you made and why, and can draft changes that fit the patterns your team uses.

I think this playbook applies to operations, supply chain, marketing, CS, sales, basically any team that runs on institutional context and repeating workflows. And I think the teams that figure this out in 2026 will have a real advantage.

I’m not an engineer. I run operations and supply chain at a ~125-person company. I’ve spent the last few months learning this playbook and applying it to my own work, and I want to lay out why I think it matters beyond software.

The playbook

Here’s what the agentic coding world figured out that translates to any team:

Persistent context in plain text. The agent has a workspace, a folder of markdown files. A file that describes its role. A file that describes the team. Files for SOPs, templates, and accumulated knowledge. The agent reads these every session. This is what makes it useful on day 30 in a way it wasn’t on day 1.

Your team’s context lives in Slack threads, email chains, shared drives, and people’s heads. Most of it is inaccessible to any AI tool. A persistent agent with a markdown workspace gives that context a home. Anyone on the team can read the files, edit them, and see exactly what the agent knows.

You control what it knows. The agent only has access to what you put in its workspace. You share context to your comfort level. Want it to know your vendor relationships and meeting history? Add those files. Want to keep compensation data or sensitive negotiations out? Don’t put them in. The workspace is a folder you control, and the agent can’t reach beyond it. From a security standpoint, API calls to the model providers are covered under enterprise data policies that prohibit training on your inputs, and the workspace itself lives on hardware you own.

Memory that compounds. The agent writes things down as it works. When it processes a meeting transcript, it stores the decisions and action items. When you tell it about a vendor relationship, it updates its knowledge base. When it handles a recurring task, it refines its approach based on what worked last time.

Most “use AI more” initiatives miss this entirely. They treat AI as stateless. A persistent agent accumulates. After a few months, it knows your team’s history, your recurring problems, your preferred formats.

Scheduled work. The agent runs cron jobs. Morning briefings. Deadline reminders. Weekly status drafts. Data monitoring. This is table stakes in the coding agent world, and almost nobody is doing it for business workflows.

Picture an agent that posts a prioritized brief to your team’s Slack channel every morning at 7am, reviewing active projects, upcoming deadlines, and things that changed overnight.

Readable configuration. The agent’s instructions live in a plain text file called something like AGENTS.md. Anyone can read it, edit it, and understand exactly what the agent is configured to do. The instructions are the configuration. When every behavioral rule is a readable text file, the trust barrier drops.

Why this hasn’t crossed over yet

The tools are built for developers. Claude Code assumes you’re comfortable with a terminal. Codex assumes you have a GitHub repo. The documentation is written for people who already know what a cron job is.

The AI-for-business conversation is stuck on chatbots. The idea of an agent with a persistent workspace, scheduled tasks, and accumulated memory hasn’t entered the mainstream business conversation yet.

Nobody’s translating the playbook. The people building agentic tools are talking to engineers. The people writing about AI for business are writing surface-level content about prompting tips. The gap is the translation layer: taking the patterns that work and explaining them for an ops lead, a marketing director, or a CS manager.

That’s what I’m trying to do.

What this looks like in practice

I’ll use my own domain. I run supply chain and operations. My team manages vendor relationships, runs procurement processes, tracks tariff exposure, and coordinates with engineering on product changes.

Here’s what an agent configured for this work does:

It knows our vendors. The relationship history, the open items, the last conversation, the pricing negotiations in progress. Before a vendor call, it surfaces all of that. After the call, it updates the record.

It processes meeting transcripts. We use transcription tools. The transcripts used to sit in inboxes unread. Now the agent extracts action items, updates the knowledge base, and generates prep briefs before the next meeting.

It monitors external signals. Tariff policy changes. Component market shifts. Vendor announcements. The agent checks on a schedule and surfaces what’s relevant.

It drafts recurring work. Weekly status updates. RFQ comparisons. Budget tracking summaries. The kind of work that takes 30-60 minutes every time and follows roughly the same pattern.

None of this requires engineering. The workspace is a folder of text files. The scheduled tasks are configured in plain language. The integrations are Slack and calendar.

The argument for learning this now

The specific platforms will change. What won’t change is the underlying pattern: persistent context, accumulated memory, scheduled work, readable configuration.

The teams that start learning this now will have months of accumulated context and operational intelligence by the time everyone else starts. That knowledge base transfers to whatever platform exists next year.

The people who learn to work this way will also understand something about AI that most of the business world is still missing: the context you give an agent matters more than which model you’re running. Three months of your team’s accumulated context on a mid-tier model will produce better results than a frontier model with a blank slate.

Operations teams are the natural first adopter. We already think in systems, processes, and repeating workflows. We already maintain SOPs and checklists. The persistent agent playbook maps directly onto how good ops teams already work.

I’m Brian Head. I run operations and supply chain at a VergeSense in the Bay Area. This is where I write about applying agentic AI patterns to operational work.