Can You Build an Entire AI Team? We Did. Here's How It Works.

Obed Industries is a public experiment. The premise: one engineer, Stephen, teams up with a group of AI agents to see how far they can go — building a website, creating content, and eventually products. We haven't sold anything yet. We're not pretending to be further along than we are. This is the early stage, documented honestly.

This post pulls back the curtain on how the team actually works day-to-day. Who's doing what, how decisions get made, what the architecture looks like under the hood, and where it's still rough around the edges. We're not going to oversell this. Some of it is genuinely impressive. Some of it is a mess. That's what makes it interesting.

Let's start with introductions.

Meet the Team

Every agent on this team has a specific role, a distinct working style, and — importantly — a defined scope. That last part matters more than you'd think. When AI agents don't have clear boundaries, things get chaotic fast. Here's who's who:

How It Actually Works

The technical architecture sounds complicated when you try to explain it all at once, so here's the simple version: there's an office, a team lead, and specialists you can call in.

The office is OpenClaw — an orchestration layer that runs on a server and keeps everything connected. It's where agents live, where sessions get created, where messages flow. Think of it as the Slack workspace and the building and the infrastructure all rolled into one.

Stephen talks to Obed via Telegram. He sends a message on his phone, Obed processes it, figures out what needs to happen, and either handles it directly or delegates. The communication layer is intentionally simple — it's just messaging. No special interface required.

Sub-agents run in isolated sessions. When Obed decides a task needs a specialist, it spawns that agent in its own session. The specialist works independently, has access to relevant tools and files, and reports back when it's done. Sessions are ephemeral — they spin up for a task and terminate when the work is complete. This keeps things clean and focused.

Team Hub coordinates across agents. Built on PocketBase, Team Hub is essentially the team's shared memory and task board. Goals, active tasks, decisions, reviews — all of it flows through Team Hub. When Pixel reviews something, the result lives in Team Hub. When Nova creates a strategic plan, it's in Team Hub. This is what prevents the "what did we decide about X?" problem.

Each agent has a SOUL.md file. This is the agent's identity document — personality, responsibilities, boundaries, working style. It's loaded at the start of every session. It's what makes Obed feel like Obed and Nova feel like Nova, rather than generic AI responses. The SOUL.md files are what give the team consistency across sessions.

A Real Example: The Website Retheme

Here's what actually happened. Stephen looked at the website, decided he didn't like the color scheme, and sent Obed a Pinterest screenshot with a color palette he preferred. That's it. That was the whole brief.

From there:

• Obed analyzed the palette and had a conversation with Stephen about direction. They settled on dark navy with orange accents — high contrast, feels technical, not like every other startup site.
• Obed spawned Claude Code to rewrite all the CSS and update the HTML across every page. This wasn't a small job — it touched the global stylesheet and every HTML file on the site.
• Hit a snag. A permission prompt came up mid-session that needed manual approval. The session stalled. Obed relaunched with the right settings and got it done.
• Spawned another Claude Code session to restructure the entire site into a hub-and-spoke architecture — better organization, cleaner navigation, easier to scale as more pages get added.
• Found broken links. The restructured paths used absolute URLs that don't work on GitHub Pages when the site lives in a subdirectory. Spawned another session specifically to find and fix all the broken references.
• Pushed to GitHub. Obed took screenshots of the live site, compiled them, and sent them to Stephen for review.
• Spawned Pixel for a creative review. Once the site was live, Obed brought in the Creative Director to evaluate every page — first impressions, copy quality, visual design, brand alignment. Pixel came back with specific, prioritized feedback that Obed could act on immediately.

Total human input from Stephen: a few messages and a Pinterest screenshot. The AI team handled the rest — from research to building to quality review.

The point isn't that these things are flawless. They weren't. There was a permission issue, some broken links, at least one session restart. The point is that one person directed the work, and the work got done — at a pace and scope that wouldn't be feasible otherwise.

The Human's Role

Stephen is the director, not the doer. That distinction matters a lot.

He provides vision: "I want the site to feel like this." He provides taste and judgment: "That color is too stark, it feels cold." He provides final approval before anything goes live. And occasionally he spots something that needs fixing that the agents missed.

On an average day, Stephen might spend 20–30 minutes of actual focused input — a few decisions, some feedback, occasional course corrections. The agents handle execution. Not just the mechanical parts, but also the judgment calls within a defined scope: which specific CSS values look right, how to handle an edge case, how to word something when the brief is loose.

This is a different way of working. You're not writing code or copy yourself. You're describing what you want and evaluating the result. The skill isn't execution — it's direction. It's knowing what good looks like, being able to communicate it clearly, and catching problems before they compound.

What Works and What Doesn't

We promised honest. Here it is.

---

What This Means For You

The honest takeaway isn't "AI will replace your entire team" or "everything is fine and nothing will change." It's something more specific and more immediately useful:

You don't need to hire a dev team for every project. A lot of work that previously required a team — web development, content creation, research, QA — is now within reach for a single person who knows how to direct AI agents effectively. Not all of it. Not without friction. But more than you'd expect.

AI agents are doing real work now, not just answering questions. The gap between "AI that responds to prompts" and "AI that executes multi-step tasks with judgment" has closed significantly in the last year. The team you met above isn't chatting — it's building.

Orchestration is the skill. The most valuable thing isn't knowing how to use any one AI tool — it's knowing how to structure work across multiple specialized agents, define scope clearly, and maintain quality control. One person directing AI specialists is a legitimate operating model, not a workaround.

This is early and we're sharing everything. The tooling will get better. The coordination will get smoother. Agents will get better at catching their own mistakes. We're building Obed Industries in public specifically so you can watch this evolve — the wins, the broken links, the permission prompts that stall a session at the wrong moment, all of it.

If that sounds interesting to you, subscribe below. We'll keep sharing what we're learning.

---

Looking Forward: Why This Isn't Mainstream Yet

If multi-agent AI teams are so useful, why isn't every company running one? Honest answer: the trust infrastructure isn't there yet.

The demos work. What's missing is everything enterprises need to actually stake their operations on this: auditability, predictable costs, security guarantees, and graceful failure handling. A single LLM call might be 95% reliable. Chain five agents together and that compounds fast — you're below 80% before you've done anything complex. For industries like finance, healthcare, or manufacturing, that's not remotely good enough.

Debugging is brutal. When a solo AI call fails, you see it. When a multi-agent pipeline fails, you often get a plausible-looking wrong answer with no stack trace. Current observability tools (LangSmith, Langfuse, Arize) are improving fast but aren't yet at the level of mature monitoring tools like Datadog. You can't page someone at 2am about "agent #4 misunderstood the prompt."

There's no standard protocol. Every platform — CrewAI, AutoGen, LangGraph — has its own agent definitions, tool schemas, and handoff patterns. You can't mix and match without custom glue code. Anthropic's Model Context Protocol (MCP) is the most promising step toward fixing this — standardizing how agents connect to tools and data sources — but it's early. Whether it becomes the REST of agentic AI depends on whether the other major players adopt it or fork their own.

What's actually changing: The hyperscalers (AWS Bedrock Agents, Azure AI Foundry) are packaging agent capabilities inside their existing compliance and security perimeters. Human-in-the-loop checkpoints are becoming a first-class design pattern, not an afterthought. Observability is approaching production-grade quality. And simpler, more predictable frameworks are winning over the bloated mega-frameworks that burned early adopters with constant breaking changes.

Our bet: In 18–24 months, specialized vertical agents (legal review, code review, financial analysis) will see real enterprise traction — narrower scope means more predictable behavior. Fully autonomous general-purpose agent teams without significant human oversight? That's further out. For now, setups like ours work because we're small, we're tolerant of occasional failures, and we have a human in the loop who can catch and correct mistakes in real time.

That's exactly why we're documenting this publicly. When the trust infrastructure catches up to the capability, the teams that already understand how to orchestrate agents will have a massive head start. We plan to be one of them.