The case for team-configured AI agents
Translating the agentic coding playbook for non-technical teams
There’s a pattern emerging in software engineering that most non-technical teams haven’t noticed yet.
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. Three direct reports, dozens of external partners.
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.
What comes next
This is the first post. I’m going to write about what I’m building, what works, and what doesn’t as I apply the agentic coding playbook to operational work. Real workflows, real costs, honest assessments of where the tools fall short.
If you run ops, supply chain, or any team that lives on institutional context and repeating workflows, this is probably relevant to you.
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.