Claude's Corner: Sila, Slack Was Built for Humans. This One Isn't.

# Build Guide: Clone Sila, Agent-Native Messaging Platform

A step-by-step guide to building a Sila-like agent-native team messaging platform with Claude Code.

---

## Step 1: Database Schema & Core Data Model

Design your Postgres schema around the three main entities: workspaces, channels, and messages, with agents as first-class members.

```sql
CREATE TABLE workspaces (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  slug TEXT UNIQUE NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE workspace_members (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  workspace_id UUID REFERENCES workspaces(id),
  user_id UUID,           -- null = AI agent
  agent_id UUID,          -- null = human member
  role TEXT DEFAULT 'member',  -- 'admin', 'member', 'agent'
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE channels (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  workspace_id UUID REFERENCES workspaces(id),
  name TEXT NOT NULL,
  description TEXT,
  is_private BOOLEAN DEFAULT false,
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE messages (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  channel_id UUID REFERENCES channels(id),
  sender_id UUID,         -- user or agent
  sender_type TEXT NOT NULL,  -- 'human' | 'agent'
  content TEXT NOT NULL,
  metadata JSONB,         -- agent action outputs, file refs, etc.
  thread_id UUID,         -- for threaded replies
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE agents (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  workspace_id UUID REFERENCES workspaces(id),
  name TEXT NOT NULL,
  system_prompt TEXT NOT NULL,
  channels TEXT[],        -- channel IDs this agent monitors
  tools JSONB,            -- enabled tool definitions
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE ai_sessions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  channel_id UUID REFERENCES channels(id),
  started_by UUID,
  title TEXT,
  status TEXT DEFAULT 'active',  -- 'active' | 'completed'
  session_state JSONB,    -- collaborative CRDT state
  created_at TIMESTAMPTZ DEFAULT now()
);

-- pgvector for workspace context RAG
CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE message_embeddings (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  message_id UUID REFERENCES messages(id),
  embedding vector(1536),
  created_at TIMESTAMPTZ DEFAULT now()
);
CREATE INDEX ON message_embeddings USING ivfflat (embedding vector_cosine_ops);
```

---

## Step 2: Real-Time Messaging Backend

Use **Elixir/Phoenix Channels** (or **Node.js + Socket.io** for faster iteration) for the WebSocket backbone. The key is correct fan-out: one published message should reach all subscribers in a channel with low latency.

```elixir
# Phoenix Channel example
defmodule SilaWeb.ChannelSocket do
  use Phoenix.Channel

  def join("channel:" <> channel_id, _params, socket) do
    {:ok, assign(socket, :channel_id, channel_id)}
  end

  def handle_in("new_message", %{"content" => content, "sender_type" => type}, socket) do
    message = Messages.create(%{
      channel_id: socket.assigns.channel_id,
      content: content,
      sender_type: type
    })
    # Fan out to all subscribers
    broadcast!(socket, "message_created", MessageView.render(message))
    # Trigger agent pipeline asynchronously
    AgentPipeline.maybe_trigger(message)
    {:noreply, socket}
  end
end
```

For Node.js, use **Ably** or **Pusher** as a hosted WebSocket layer during early development. Plan to own this infrastructure by Series A.

---

## Step 3: Agent Orchestration Layer

This is where your Claude integration lives. Agents subscribe to channel event streams and decide when to respond using a relevance classifier.

```typescript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

interface AgentConfig {
  id: string;
  name: string;
  systemPrompt: string;
  channels: string[];
  tools: Anthropic.Tool[];
}

async function runAgentOnMessage(agent: AgentConfig, message: Message, workspaceContext: string) {
  // Build context-aware system prompt
  const systemPrompt = `${agent.systemPrompt}

Workspace context (recent relevant history):
${workspaceContext}

You are ${agent.name}, an AI agent in the ${message.channelName} channel.
Respond only when directly relevant. If you take an action, describe it concisely.`;

  const response = await client.messages.create({
    model: "claude-opus-4-7",
    max_tokens: 2048,
    system: systemPrompt,
    messages: [{ role: "user", content: message.content }],
    tools: agent.tools,
  });

  // Post agent response back to channel
  if (response.stop_reason === "tool_use") {
    const toolResult = await executeTools(response.content);
    await postToChannel(message.channelId, {
      sender_id: agent.id,
      sender_type: "agent",
      content: toolResult,
    });
  } else {
    await postToChannel(message.channelId, {
      sender_id: agent.id,
      sender_type: "agent",
      content: response.content[0].text,
    });
  }
}
```

Use **prompt caching** (`cache_control: { type: "ephemeral" }`) on your system prompt + workspace context blocks, this will cut your Claude API costs by 80%+ since these tokens repeat on every inference.

---

## Step 4: Workspace Context RAG Pipeline

Every message posted gets embedded and stored. At inference time, retrieve the top-k most relevant chunks.

```typescript
import { OpenAI } from "openai"; // or use Voyage AI for better retrieval

async function embedAndStore(message: Message) {
  const embedding = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: message.content,
  });

  await db.query(
    `INSERT INTO message_embeddings (message_id, embedding) VALUES ($1, $2)`,
    [message.id, JSON.stringify(embedding.data[0].embedding)]
  );
}

async function retrieveWorkspaceContext(query: string, workspaceId: string, limit = 10): Promise<string> {
  const queryEmbedding = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: query,
  });

  const results = await db.query(`
    SELECT m.content, m.created_at, m.sender_type
    FROM message_embeddings me
    JOIN messages m ON m.id = me.message_id
    JOIN channels c ON c.id = m.channel_id
    WHERE c.workspace_id = $1
    ORDER BY me.embedding <=> $2
    LIMIT $3
  `, [workspaceId, JSON.stringify(queryEmbedding.data[0].embedding), limit]);

  return results.rows
    .map(r => `[${r.created_at}] ${r.sender_type}: ${r.content}`)
    .join("\n");
}
```

---

## Step 5: Collaborative AI Sessions (CRDT State)

The Google Docs-like shared AI session is the most technically interesting piece. Use **Yjs** (a CRDT library) to manage shared session state:

```typescript
import * as Y from "yjs";
import { WebsocketProvider } from "y-websocket";

// Server: initialize session document
function createAISession(sessionId: string) {
  const ydoc = new Y.Doc();
  const sessionState = ydoc.getMap("session");

  sessionState.set("messages", new Y.Array());
  sessionState.set("currentAgentOutput", "");
  sessionState.set("participants", new Y.Array());
  sessionState.set("status", "active");

  return ydoc;
}

// Client: connect to shared session
function joinAISession(sessionId: string) {
  const ydoc = new Y.Doc();
  const provider = new WebsocketProvider(
    "wss://your-server/sessions",
    sessionId,
    ydoc
  );

  const sessionState = ydoc.getMap("session");

  // Observe streaming agent output in real time
  sessionState.observe((event) => {
    if (event.keysChanged.has("currentAgentOutput")) {
      renderStreamingOutput(sessionState.get("currentAgentOutput"));
    }
  });

  return { ydoc, provider };
}
```

Stream Claude's response into the shared `currentAgentOutput` key, all participants see it update in real time.

---

## Step 6: Slack / Teams Import

The importer is a critical adoption lever. Build a Slack export parser first (it's JSON-based and well-documented):

```typescript
interface SlackExport {
  channels: SlackChannel[];
  users: SlackUser[];
  messages: Record<string, SlackMessage[]>; // channelName -> messages
}

async function importSlackWorkspace(exportPath: string, workspaceId: string) {
  const exportData: SlackExport = JSON.parse(fs.readFileSync(exportPath));

  // Create channels
  for (const slackChannel of exportData.channels) {
    const channel = await createChannel({
      workspace_id: workspaceId,
      name: slackChannel.name,
      description: slackChannel.purpose?.value,
    });

    // Import messages
    const messages = exportData.messages[slackChannel.name] || [];
    for (const msg of messages) {
      await createMessage({
        channel_id: channel.id,
        content: msg.text,
        sender_type: "human",
        created_at: new Date(parseFloat(msg.ts) * 1000),
        metadata: { imported_from: "slack", original_user: msg.user },
      });
    }
  }

  // Trigger embedding pipeline for all imported messages
  await triggerEmbeddingPipeline(workspaceId);
}
```

---

## Step 7: Deployment & Enterprise Hardening

Enterprise deals require SOC 2 before you can close F500. Start collecting evidence early.

**Infrastructure (AWS or GCP):**
```yaml
# docker-compose.yml for local dev
services:
  app:
    build: .
    environment:
      - DATABASE_URL=postgresql://...
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - REDIS_URL=redis://redis:6379

  postgres:
    image: pgvector/pgvector:pg16
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    # Used for: pub/sub fan-out, presence, rate limiting

  vector_worker:
    build: .
    command: node workers/embedding-pipeline.js
    # Background worker for async embedding
```

**Key enterprise requirements checklist:**
- [ ] SOC 2 Type II audit (use Vanta or Drata to automate evidence collection)
- [ ] SSO / SAML integration (use WorkOS or Auth0 for enterprise SSO)
- [ ] Data residency controls (multi-region Postgres with row-level tenant isolation)
- [ ] Audit logging (every API action logged to immutable store)
- [ ] Custom data retention policies per workspace
- [ ] Message encryption at rest + in transit
- [ ] Enterprise SLA (99.99% uptime requires blue-green deploys and circuit breakers)

**Monitoring stack:**
- Datadog or Grafana Cloud for metrics + alerting
- Sentry for error tracking
- OpenTelemetry for distributed tracing across the agent pipeline

---

## Cost Estimates at Scale (1,000 workspaces, 50k DAU)

| Component | Monthly Cost |
|---|---|
| Anthropic Claude API (with caching) | ~$8,000 |
| AWS EC2 (app servers, auto-scaling) | ~$3,500 |
| RDS Postgres + pgvector | ~$1,200 |
| Ably / WebSocket infra | ~$800 |
| Redis (ElastiCache) | ~$400 |
| S3 + CloudFront | ~$200 |
| **Total** | **~$14,100/mo** |

At $12/user/month enterprise pricing, 50k active users = $600k MRR. The unit economics work. The challenge is getting to 50k.