Key Takeaways

  • Dave Kerr built Arc, an open-source toolset that turns AI agents into standard Kubernetes workloads instead of messy local Python scripts.
  • Regulated enterprise clients demand audit logs, secrets management through tools like HashiCorp Vault, and role-based access control before running any LLM code.
  • Arc strips away visual workflow builders in favor of pure declarative YAML files for agents, system prompts, Anthropic SDK integrations, and Model Context Protocol (MCP) tool associations.
  • Production automation favors deterministic code loops over agentic improvisation: clients prefer a quick Python script that lists files and fans out tasks over an open-ended agent prompt.

Why Local Python Agent Loops Fail in Production

Every AI engineer begins in the same place. You install LangChain or the Anthropic SDK, write a while-loop in a local Python file, feed it an API key, and marvel as Claude calls tools on your laptop. It works until a compliance officer asks who initiated a database query, or until an unconstrained agent burns five hundred dollars in API credits on an endless recursion loop.

Kerr noticed this gap while working with enterprise clients. These teams did not want another flashy workflow canvas. They wanted containment, secrets hygiene, and auditability. They needed to run agents inside the same infrastructure perimeter where they already run their production backends. As Kerr put it, “one of the things that my team are building and building an open source at the moment, it's a set of like tools for Kubernetes that mean you can run agents, and treat them a little bit like services you'd deploy and you'd manage and govern.” (play from 15:16)

Local scripts lack resource limits and blast-radius control. When you deploy agents as microservices inside a Kubernetes cluster, you get those boundaries for free. Memory limits kill runaway processes. Network policies block unauthorized external calls. Standard pods isolate agent failures from the rest of the company.

Boring Infrastructure Beats Flashy Frameworks

Enterprise software buyers care about security audits, not demo videos. When large clients evaluate agent software, their initial questions have nothing to do with intelligence. Kerr recalled a typical enterprise request: “This client need to know which person created which query and who edited it. Can we get this out of the box? And it's like, 'Yeah, we've got audit logging. It will tell you the resources that have been created and who created them.'” (play from 37:04)

To solve this, Kerr built Arc. The project deliberately avoids hype. “Arc is kind of boring,” (play from 38:01) Kerr admitted. “It doesn't give you this kind of like sexy workflow building type thing, but it allows people to define agents as YAML, or define agents that run against Anthropic SDKs, put them all in a Git repository, and then fire them up into a cluster kind of almost in the same way that you deploy microservices into a cluster.” (play from 38:02)

By treating agents as Kubernetes manifests, your entire prompt pipeline becomes version-controlled. If an agent misbehaves after an engineer tweaks its system prompt, you do not search someone's terminal history. You check the Git commit. You run standard CI/CD checks, test the prompt diff, and roll back using standard GitOps tooling like ArgoCD.

Determinism Over Agency

The industry preaches full autonomy, but companies paying real bills demand predictability. Real production tasks require strict guardrails. Kerr observed that when companies try to get work done, they actively strip away autonomy: “a lot of the time they wanted deterministic steps. They don't want to say to an agent, 'Read this folder and do X.' They want to say instead, with a bit of Python code, 'List the contents of this folder, and then for each one, fan out an operation.'” (play from 35:47)

Agents should handle discrete probabilistic steps, while deterministic code handles orchestration. An agent should summarize an individual document, but standard code should handle directory reading, queue management, retries, and network calls. When you need predictable software, standard processes give you checkpoints where humans can observe state and stop failures.

What to Do With This

Audit your internal agent tools by noon tomorrow. If your team runs customer-facing agents from unstructured Python scripts with static API keys in environment variables, move those keys into HashiCorp Vault or Kubernetes secrets immediately. Then, take the system prompt and tool definitions out of your application code and commit them into a declarative YAML manifest in Git.