How to Build an AI-Powered Company OS That Manages 7 Departments — Step by Step

What You're About to Build

By the end of this tutorial, you'll understand the exact architecture behind a system that manages an entire company through AI. Not theory — this is the real blueprint we use daily at WizardingCode.

You'll learn how to:

• Structure an AI operating system with specialized departments
• Create AI personas that think like real team members
• Set up a persistent knowledge brain that gets smarter over time
• Connect 14+ external tools through one unified protocol
• Scaffold production-ready projects in under 2 minutes
• Build compound workflows where departments collaborate

Prerequisites: Familiarity with command-line tools, basic understanding of AI assistants (Claude, ChatGPT), and a desire to stop being a bottleneck in your own business.

Step 1: The Architecture Decision That Changes Everything

Most people use AI like a search engine: ask a question, get an answer, forget everything.

That's like hiring an employee, getting one task done, then giving them amnesia.

The first breakthrough in building a company OS is understanding the three layers:

┌─────────────────────────────────────────┐
│          INTELLIGENCE LAYER             │
│     (Claude AI + System Prompts)        │
├─────────────────────────────────────────┤
│          DEPARTMENT LAYER               │
│  Dev | Mkt | Ecom | Fin | Ops | Strat  │
├─────────────────────────────────────────┤
│          INTEGRATION LAYER              │
│    MCPs: Supabase, Shopify, Gmail...    │
├─────────────────────────────────────────┤
│          KNOWLEDGE LAYER                │
│     Obsidian Vault + Memory Bank        │
└─────────────────────────────────────────┘

Intelligence Layer — The AI brain. Claude with specialized system prompts that define personality, expertise, and decision-making frameworks for each department.

Department Layer — The org chart. Seven departments, each with specific commands, workflows, sub-skills, and output paths. This is where work actually happens.

Integration Layer — The nervous system. Model Context Protocol (MCP) connections to every external tool your business uses. The AI doesn't just think — it acts.

Knowledge Layer — The memory. An Obsidian vault where every decision, report, and insight is stored permanently. The system gets smarter every single day.

Key insight: These layers aren't separate tools. They're one unified system where a marketing task can reference development documentation, which was informed by a strategic analysis, all stored in the same knowledge brain.

Step 2: Setting Up the Department Structure

Here's the folder structure that makes everything work:

arka-os/
├── CLAUDE.md              # Master system prompt
├── arka/                  # Core system
│   ├── SKILL.md           # System-level commands
│   ├── agents/            # Cross-department agents
│   ├── scripts/           # Utility scripts
│   ├── skills/            # System skills
│   └── templates/         # Output templates
├── departments/
│   ├── dev/               # Development
│   │   ├── SKILL.md       # Dev commands & workflows
│   │   ├── agents/        # Dev-specific AI agents
│   │   ├── scripts/       # Build, deploy, scaffold scripts
│   │   ├── skills/        # Sub-skills (scaffold, mcp)
│   │   └── templates/     # Code templates
│   ├── marketing/
│   │   ├── SKILL.md
│   │   ├── agents/
│   │   ├── scripts/
│   │   ├── skills/
│   │   └── templates/
│   ├── ecommerce/
│   ├── finance/
│   ├── operations/
│   ├── strategy/
│   └── knowledge/
├── knowledge/             # Knowledge config
├── mcps/                  # MCP registry & profiles
│   ├── registry.json      # All available MCPs
│   ├── profiles/          # Pre-configured MCP sets
│   ├── scripts/           # MCP management scripts
│   └── stacks/            # Package configurations
└── projects/              # Active project contexts

The SKILL.md Pattern

Every department has a SKILL.md file at its root. This is the master instruction file that tells the AI:

1. What this department does (description, scope)
2. Available commands (with exact syntax)
3. Personas involved (who responds and in what context)
4. Sub-skills (links to specialized workflow files)
5. Output paths (where to save results in the Obsidian vault)

Here's a simplified example for the Development department:

---
name: dev
description: >
  Development department. Scaffolds projects, implements features,
  reviews code, manages APIs, testing, deployment, and MCP configuration.
allowed-tools: Read, Grep, Glob, Bash, WebFetch, Write
---

Why this matters: The AI doesn't guess what to do. Each department has explicit instructions, explicit commands, and explicit output expectations. This is what turns a generic AI into a functional department.

Step 3: The Master System Prompt (CLAUDE.md)

The CLAUDE.md file at the root is the brain of the entire operation. This is where you define:

Identity and Principles

## Identity
- **Company:** YourCompany
- **System:** Your OS Name
- **Purpose:** AI-augmented company operating system

## Core Principles
1. One System, Many Departments
2. Personas Are Team Members
3. Knowledge Compounds
4. Context Is King
5. Action Over Theory
6. Client-Ready Always
7. Obsidian Is The Brain

Default Tech Stack

Define your standard tools so every project starts with the same foundation:

## Tech Stack
| Layer      | Technology              |
|-----------|------------------------|
| Backend    | Laravel 11 (PHP 8.3)   |
| Frontend   | Vue 3 + TypeScript      |
| Database   | PostgreSQL (Supabase)   |
| CSS        | Tailwind CSS            |
| Deploy     | Vercel / Azure          |

Department Command Registry

Map every command to its department so the AI routes correctly:

## Department Commands
| Department  | Prefix   | Purpose                    |
|------------|---------|----------------------------|
| Development | /dev     | Code, build, deploy        |
| Marketing   | /mkt     | Content, social, ads       |
| Finance     | /fin     | Planning, investment       |
| Operations  | /ops     | Automation, tasks, email   |
| Strategy    | /strat   | Analysis, brainstorming    |
| Knowledge   | /kb      | Learn, search, personas    |

Coding Standards

Enforce consistency across every project:

## Coding Standards
- Laravel: Services + Repositories pattern
- Vue/Nuxt: Composition API only, TypeScript
- Git: Conventional commits, feature branches
- Never: Options API, raw SQL in controllers

The power move: This single file ensures that whether you're working on a client project at 2 PM or reviewing code at midnight, the AI operates with the same standards, principles, and knowledge.

Step 4: Building the MCP Integration Layer

This is where ARKA OS goes from "smart assistant" to "operational command center."

What is MCP?

Model Context Protocol (MCP) lets AI assistants connect to external tools and services. Instead of copying data between apps, the AI can directly read your database, send emails, manage your calendar, update your project board, and deploy your code.

The Registry

Create a central catalog of all available MCPs:

// mcps/registry.json
{
  "mcps": [
    {
      "name": "obsidian",
      "category": "base",
      "description": "Read/write to Obsidian vault"
    },
    {
      "name": "supabase",
      "category": "external",
      "description": "Database management"
    },
    {
      "name": "shopify",
      "category": "external",
      "description": "E-commerce operations"
    },
    {
      "name": "gmail",
      "category": "external",
      "description": "Email communication"
    }
  ]
}

MCP Profiles

Different project types need different tools. Profiles solve this:

base:       obsidian, context7, playwright, memory-bank, sentry, clickup
laravel:    base + laravel-boost, serena
nuxt:       base + nuxt, nuxt-ui
ecommerce:  base + laravel-boost, serena, shopify
full-stack: base + laravel-boost, serena, nuxt, nuxt-ui

When you run /dev mcp apply laravel, a script reads the profile, generates the correct .mcp.json configuration, and your project instantly has access to all the tools it needs.

The 14 MCPs We Use

Here's our complete integration map:

The compound effect: When the marketing department creates a campaign, it can check the project timeline in ClickUp, reference brand assets in Google Drive, create visuals in Canva, schedule email sends through Gmail, and log everything in Obsidian — all in one workflow.

Step 5: The Knowledge Layer (Your AI's Memory)

This is the feature that separates a company OS from a fancy chatbot.

Why Obsidian?

• Local-first: Your data stays on your machine
• Markdown: Universal, portable, version-controllable
• Wikilinks: Connect ideas naturally with [[Note Name]]
• Graph view: Visualize knowledge relationships
• Extensible: Plugins for everything
• Fast: Handles 10,000+ notes without breaking a sweat

Vault Structure

Map your departments to vault folders:

Obsidian Vault/
├── Projects/
│   └── <project-name>/
│       ├── Home.md
│       ├── Architecture/
│       └── Docs/
├── Personas/           # AI persona definitions
├── Sources/            # Learned content
├── Topics/             # Knowledge topics
├── 🧠 Knowledge Base/ # Processed insights
├── WizardingCode/
│   ├── Marketing/
│   ├── Ecommerce/
│   ├── Finance/
│   ├── Operations/
│   └── Strategy/

Conventions That Matter

# Every note has YAML frontmatter
---
type: project | persona | source | topic | report
title: "Note Title"
tags: [kebab-case-tags]
date: 2026-03-15
---

Use wikilinks ([[Note Name]]) to connect related notes. Over time, your knowledge graph becomes a living map of your entire business intelligence.

The Learning Workflow

When you run /kb learn https://some-industry-report.com, the knowledge department:

1. Fetches and reads the content
2. Extracts key insights and data points
3. Creates a structured note in Sources/
4. Links it to relevant Topics/
5. Updates any related Personas/ with new knowledge

Next time any department needs information on that topic, it's already in the brain.

Step 6: Project Scaffolding — From Zero to Production in 2 Minutes

This is the workflow that makes other developers' jaws drop.

How It Works

/dev scaffold laravel client-crm

Behind the scenes:

1. Clone starter kit from Git
   └── git@andreagroferreira:andreagroferreira/laravel-starter-kit.git

2. Install mandatory packages (in order!)
   ├── laravel/boost → php artisan boost:install
   ├── laravel/horizon → php artisan horizon:install
   ├── echolabs/prism (AI SDK)
   └── php-mcp/laravel → php artisan vendor:publish

3. Apply MCP profile "laravel"
   └── Generates .mcp.json with 9 pre-configured MCPs

4. Configure Laravel Herd
   └── Local development environment ready

5. Create Obsidian project page
   └── Projects/client-crm/Home.md with architecture template

6. Result: Production-ready project
   └── Code, configs, MCPs, docs — everything done

Scaffold Types Available

Each scaffold comes from a real, maintained Git repository — not a template generator. Real code, real configurations, real best practices.

Step 7: Building Cross-Department Workflows

This is where the magic happens. Departments don't work in silos — they collaborate.

Example: New Client Onboarding (Full Workflow)

Step 1: Strategy analyzes the client's market
  /strat analyze market <industry>
  → Output: Market analysis in Obsidian

Step 2: Development scaffolds the project
  /dev scaffold laravel <project-name>
  → Output: Production-ready codebase + MCP config

Step 3: Marketing creates the proposal
  /mkt content proposal <project-name>
  → References: Strategy's market analysis
  → Output: Client-ready proposal document

Step 4: Finance creates the forecast
  /fin forecast <project-name>
  → References: Strategy analysis + project scope
  → Output: Financial projection in Obsidian

Step 5: Operations sets up the project management
  /ops setup project <project-name>
  → Creates: ClickUp tasks, calendar milestones, client comm templates

Step 6: Knowledge logs everything
  /kb index project <project-name>
  → Indexes: All generated docs into searchable knowledge base

Total time: ~20 minutes. Total departments involved: 6. Total context lost: zero.

Every output references previous outputs. The proposal includes market data from strategy. The financial forecast references the project scope from development. Operations creates tasks based on all of the above.

The Feedback Loop

Here's what makes this truly powerful: every project makes the next one better.

When the knowledge department indexes a completed project, it captures:

• What worked and what didn't
• Actual vs. projected timelines
• Client feedback patterns
• Technical decisions and their outcomes

Six months and 20 projects later, your strategy analysis isn't generic — it's informed by your entire project history.

Step 8: The Daily Rhythm

Once your company OS is running, your daily workflow looks like this:

Morning (5 minutes)

/arka standup

You get: project status, pending tasks, today's calendar, overnight errors, strategic priorities. You know exactly what to focus on.

Execution (Working Hours)

Switch between departments as needed. The AI maintains context across all of them:

/dev feature implement user-auth for client-crm
/mkt content linkedin-post about ai-automation
/fin review invoice client-abc
/ops email follow-up client-xyz

Each command goes to the right department, the right persona, with the right context.

End of Day (2 minutes)

/arka status
/kb daily-summary

Log what was accomplished. The knowledge base updates. Tomorrow's standup will reference today's progress.

Step 9: Scaling Your OS

Adding New Departments

The structure is modular. Want an HR department? Create:

departments/hr/
├── SKILL.md         # Commands: /hr recruit, /hr onboard, /hr policy
├── agents/          # HR Specialist persona
├── scripts/
├── skills/
└── templates/       # Job descriptions, offer letters, policies

Add the /hr prefix to CLAUDE.md, define the commands, and you have a new department.

Adding New MCPs

Find a new tool you want to integrate? Add it to the registry:

{
  "name": "new-tool",
  "category": "external",
  "description": "What it does"
}

Add it to the relevant profile, and every new project of that type automatically gets access.

Adding New Project Types

Create a new Git starter kit, register it as a scaffold type, assign an MCP profile, and your team can scaffold that project type in 2 minutes.

What You Should Build First

If you're starting from scratch, here's the priority order:

1. CLAUDE.md — Define your identity, principles, and tech stack
2. Knowledge Layer — Set up your Obsidian vault structure
3. Development Department — Your most-used department, with scaffolding
4. MCP Base Profile — Connect your essential tools (Obsidian, task manager, memory)
5. One More Department — Whatever you spend the most time on after development
6. Cross-Department Workflows — Start connecting departments together

Don't try to build all 7 departments at once. Start with 2, make them excellent, then expand.

The Bigger Picture

Building a company OS isn't a weekend project — it's an evolving system that grows with your business.

But here's what most people miss: you don't have to build it yourself.

At WizardingCode, we've already built this system, battle-tested it across dozens of real projects, and refined it over months of daily use. We can deploy a customized version for your business — tailored to your industry, your tools, your workflows.

Whether you're a developer who wants to stop context-switching, an agency owner who needs to scale without hiring, or a startup founder who needs to move faster — an AI-powered company OS is the unfair advantage you've been looking for.

The question isn't whether you need one. It's how fast you can get one running.

Let's build yours →

This tutorial is based on ARKA OS, the internal operating system powering WizardingCode. Every feature described is in production use today.