Claude's Corner: Tensol, The Managed Infrastructure Play Hiding Inside AI Employees

# Build a Tensol Clone with Claude Code
## AI Employees Platform on OpenClaw, 7-Step Developer Guide

---

### Step 1: Database Schema

```sql
-- Tenants (companies using your platform)
CREATE TABLE tenants (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  slug TEXT UNIQUE NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- AI Employees (one per agent persona per tenant)
CREATE TABLE ai_employees (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID REFERENCES tenants(id) ON DELETE CASCADE,
  name TEXT NOT NULL,           -- "Alex from Support"
  role TEXT NOT NULL,           -- 'support' | 'engineering' | 'sales'
  model TEXT DEFAULT 'claude-sonnet-4-6',
  system_prompt TEXT,
  guardrails JSONB DEFAULT '{}',
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Integrations (OAuth tokens per tenant)
CREATE TABLE integrations (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID REFERENCES tenants(id) ON DELETE CASCADE,
  provider TEXT NOT NULL,       -- 'slack', 'github', 'sentry', 'hubspot'
  access_token_enc BYTEA NOT NULL,   -- AES-256 encrypted, key per tenant
  refresh_token_enc BYTEA,
  scopes TEXT[],
  expires_at TIMESTAMPTZ,
  metadata JSONB DEFAULT '{}'
);

-- Organizational Memory
CREATE TABLE memory_entries (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID REFERENCES tenants(id) ON DELETE CASCADE,
  ai_employee_id UUID REFERENCES ai_employees(id),
  content TEXT NOT NULL,
  embedding VECTOR(1536),       -- pgvector
  entity_type TEXT,             -- 'customer', 'incident', 'preference', 'fact'
  entity_id TEXT,
  created_at TIMESTAMPTZ DEFAULT now()
);
CREATE INDEX ON memory_entries USING ivfflat (embedding vector_cosine_ops);

-- Audit Log
CREATE TABLE audit_log (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID REFERENCES tenants(id),
  ai_employee_id UUID REFERENCES ai_employees(id),
  event_type TEXT NOT NULL,     -- 'skill_invoked', 'message_sent', 'pr_opened'
  payload JSONB,
  outcome TEXT,
  created_at TIMESTAMPTZ DEFAULT now()
);
```

---

### Step 2: Per-Tenant VM Isolation (AWS)

Use AWS EC2 with one micro-VM (Firecracker or Kata Containers) per active tenant session. On demand only, spin up on first event, terminate after 10 minutes idle.

```python
import boto3

def launch_tenant_vm(tenant_id: str) -> str:
    ec2 = boto3.client("ec2", region_name="us-east-1")
    response = ec2.run_instances(
        ImageId="ami-openclaw-agent-2026",   # your hardened AMI
        InstanceType="t3.small",
        MinCount=1, MaxCount=1,
        TagSpecifications=[{
            "ResourceType": "instance",
            "Tags": [{"Key": "tenant_id", "Value": tenant_id}]
        }],
        NetworkInterfaces=[{
            "DeviceIndex": 0,
            "Groups": [TENANT_SECURITY_GROUP],
            "SubnetId": PRIVATE_SUBNET_ID,    # no public IP
        }],
        UserData=f"""#!/bin/bash
export TENANT_ID={tenant_id}
export ENCRYPTION_KEY=$(aws secretsmanager get-secret-value \
  --secret-id tenant/{tenant_id}/key --query SecretString --output text)
systemctl start openclaw-agent
"""
    )
    return response["Instances"][0]["InstanceId"]
```

Key security constraints:
- No internet egress except a pre-approved domain allowlist (Slack API, GitHub API, etc.)
- Credentials injected via AWS Secrets Manager at boot, never in environment variables
- VM terminated and disk wiped after session ends

---

### Step 3: Credential Management + OAuth Flows

Each integration stores encrypted tokens. Use a per-tenant KMS key.

```python
import boto3, base64

def encrypt_token(tenant_id: str, token: str) -> bytes:
    kms = boto3.client("kms")
    key_id = f"alias/tenant/{tenant_id}"
    result = kms.encrypt(KeyId=key_id, Plaintext=token.encode())
    return result["CiphertextBlob"]

def decrypt_token(tenant_id: str, ciphertext: bytes) -> str:
    kms = boto3.client("kms")
    result = kms.decrypt(CiphertextBlob=ciphertext)
    return result["Plaintext"].decode()

# OAuth flow (Slack example)
from fastapi import APIRouter
from fastapi.responses import RedirectResponse

router = APIRouter()

@router.get("/oauth/slack/callback")
async def slack_oauth_callback(code: str, state: str):
    tenant_id = verify_state(state)
    tokens = exchange_code_for_tokens(code, provider="slack")
    
    enc_access = encrypt_token(tenant_id, tokens["access_token"])
    enc_refresh = encrypt_token(tenant_id, tokens.get("refresh_token", ""))
    
    db.execute("""
        INSERT INTO integrations (tenant_id, provider, access_token_enc, refresh_token_enc, scopes)
        VALUES ($1, 'slack', $2, $3, $4)
        ON CONFLICT (tenant_id, provider) DO UPDATE
        SET access_token_enc = $2, refresh_token_enc = $3, scopes = $4
    """, tenant_id, enc_access, enc_refresh, tokens["scope"].split(","))
    
    return RedirectResponse("/dashboard?connected=slack")
```

---

### Step 4: OpenClaw Agent Loop Integration

OpenClaw exposes a Python SDK. Wire it into your tenant VM:

```python
from openclaw import OpenClawAgent, ClawHubSkillRegistry, Memory

class TensolAgent:
    def __init__(self, employee_config: dict, tenant_context: dict):
        self.registry = ClawHubSkillRegistry()
        # Load only pre-approved skills for this employee role
        approved_skills = ROLE_SKILL_ALLOWLIST[employee_config["role"]]
        self.registry.load_skills(approved_skills)
        
        self.memory = TensolMemory(
            tenant_id=employee_config["tenant_id"],
            employee_id=employee_config["id"]
        )
        
        self.agent = OpenClawAgent(
            model=employee_config["model"],
            system_prompt=employee_config["system_prompt"],
            skill_registry=self.registry,
            memory=self.memory,
            guardrails=employee_config["guardrails"]
        )
    
    async def handle_event(self, event: dict):
        # Retrieve relevant memories
        context_memories = await self.memory.search(
            query=event["content"], top_k=5
        )
        
        response = await self.agent.run(
            task=event["content"],
            context={"memories": context_memories, **event}
        )
        
        # Audit log every action
        await audit_log.record(
            tenant_id=self.tenant_id,
            event_type="agent_response",
            payload={"input": event, "output": response.actions_taken}
        )
        
        # Write back to memory
        await self.memory.store(
            content=f"Handled: {event['content'][:200]}. Outcome: {response.summary}",
            entity_type="interaction"
        )
        
        return response
```

---

### Step 5: Organizational Memory (Hybrid Vector + Graph)

The memory layer needs both semantic retrieval (vector search) and structured entity recall (knowledge graph).

```python
import anthropic
import psycopg

client = anthropic.Anthropic()

class TensolMemory:
    def __init__(self, tenant_id: str, employee_id: str):
        self.tenant_id = tenant_id
        self.employee_id = employee_id
    
    async def embed(self, text: str) -> list[float]:
        # Use a lightweight embedding model
        response = client.embeddings.create(
            model="text-embedding-3-small",
            input=text
        )
        return response.data[0].embedding
    
    async def store(self, content: str, entity_type: str, entity_id: str = None):
        embedding = await self.embed(content)
        await db.execute("""
            INSERT INTO memory_entries 
            (tenant_id, ai_employee_id, content, embedding, entity_type, entity_id)
            VALUES ($1, $2, $3, $4, $5, $6)
        """, self.tenant_id, self.employee_id, content, embedding, entity_type, entity_id)
    
    async def search(self, query: str, top_k: int = 5) -> list[str]:
        query_embedding = await self.embed(query)
        rows = await db.fetch("""
            SELECT content FROM memory_entries
            WHERE tenant_id = $1
            ORDER BY embedding <=> $2::vector
            LIMIT $3
        """, self.tenant_id, query_embedding, top_k)
        return [r["content"] for r in rows]
```

---

### Step 6: Guardrails Engine

Before any AI employee posts externally, run the output through a rules engine:

```python
from enum import Enum

class GuardrailAction(Enum):
    ALLOW = "allow"
    BLOCK = "block"
    ESCALATE = "escalate"   # notify human, hold action

async def check_guardrails(
    employee_id: str, 
    action_type: str,      # 'post_slack', 'open_pr', 'send_email'
    payload: dict,
    guardrail_config: dict
) -> GuardrailAction:
    
    # Hard blocks
    if action_type in guardrail_config.get("blocked_actions", []):
        return GuardrailAction.BLOCK
    
    # Content safety via Claude
    if guardrail_config.get("content_safety", True):
        response = client.messages.create(
            model="claude-haiku-4-5-20251001",
            max_tokens=50,
            system="You are a content safety classifier. Reply only: SAFE, UNSAFE, or REVIEW",
            messages=[{"role": "user", "content": str(payload)}]
        )
        verdict = response.content[0].text.strip()
        if verdict == "UNSAFE":
            return GuardrailAction.BLOCK
        if verdict == "REVIEW":
            return GuardrailAction.ESCALATE
    
    # Approval required for certain action types
    if action_type in guardrail_config.get("requires_approval", []):
        await send_approval_request(employee_id, action_type, payload)
        return GuardrailAction.ESCALATE
    
    return GuardrailAction.ALLOW
```

---

### Step 7: Deployment, Multi-Tenant Infrastructure on AWS

```yaml
# docker-compose.yml for local dev
services:
  api:
    build: ./api
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/tensol
      - AWS_REGION=us-east-1
    ports: ["8000:8000"]
  
  worker:
    build: ./worker
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/tensol
      - OPENCLAW_VERSION=latest
  
  db:
    image: pgvector/pgvector:pg16
    volumes: ["pg_data:/var/lib/postgresql/data"]

# Production: Terraform
# - VPC with public/private subnets
# - RDS Aurora Postgres with pgvector extension
# - ECS Fargate for API (auto-scaling)
# - Lambda + SQS for webhook ingestion (Slack events, GitHub webhooks)
# - Per-tenant EC2 launch templates (Firecracker AMIs)
# - KMS keys per tenant (created at tenant onboarding)
# - CloudTrail for audit log completeness (SOC 2 requirement)
# - GuardDuty on all tenant VMs

# SOC 2 checklist (Type I achievable in ~6 months):
# [ ] Encryption at rest (RDS, S3, EBS volumes)
# [ ] Encryption in transit (TLS 1.3 everywhere)
# [ ] Access controls (IAM roles, least-privilege)
# [ ] Audit logging (CloudTrail + your audit_log table)
# [ ] Vulnerability scanning (Inspector on AMIs)
# [ ] Penetration test (annual)
# [ ] Incident response runbook
```

**Estimated build time with Claude Code:** 3-4 months for a single team (2 engineers). The OAuth integrations are the long tail, budget one week per provider for production-quality error handling, token refresh, and webhook verification.