Running autonomously since January 2026

Ciel

An autonomous operations agent that ingests signals, triages work, drafts communications, generates specs, implements code, and evolves itself, managing 6 products for a single engineering leader.

Next.js 16TypeScript 5Prisma 7Claude 4Cursor CLIPostgreSQL

DB Models

Agent Tools

PM2 Daemons

API Routes

Web Pages

Brain Intents

Architecture

A pipeline-based system where raw signals flow through classification, specification, and implementation. An AI brain orchestrates decisions at every stage.

Signal

TriageItem

Spec

Implementation

Draft

MeetingBrief

Post

Ingest Layer

Gmail, Calendar, Drive, Google Chat, Jira, Kayako, Read.AI → unified Signal model

Intelligence Layer

Cursor CLI agents + Anthropic Claude API fallback + 5-tier model router

Delivery Layer

Google Chat bot, Web UI, email drafts, GitHub PRs, notifications

Signal→TriageItem

→Spec→Implementation

↘Draft|MeetingBrief|Post

Ingest Layer

Gmail, Calendar, Drive, Google Chat, Jira, Kayako, Read.AI → unified Signal model

Intelligence Layer

Cursor CLI agents + Anthropic Claude API fallback + 5-tier model router

Delivery Layer

Google Chat bot, Web UI, email drafts, GitHub PRs, notifications

Three Operational Modes

Full

CLI agents, MCP tools, file intelligence

Limited

Anthropic API fallback, DB tools only

Degraded

Offline message, minimal functionality

Capabilities

Six autonomous systems working in concert, from raw signal ingestion through to shipped code and published content.

Signal Ingestion & Triage

Monitors 7 sources, classifies signals into actionable work with urgency scoring.

Gmail, Calendar, Drive, Google Chat, Jira, Kayako, Read.AI
LLM-powered classification with learned rules injection
Entity correlation graph for deduplication
Automatic partner resolution and product tagging

Spec Generation & Implementation

Converts approved work into technical specs, then autonomously implements via Cursor CLI.

Auto-generates specs from triage items
Spawns Cursor CLI agents for code changes
Creates GitHub PRs with retry logic (max 3)
Test discovery and validation pipeline

Draft Communications

Generates voice-calibrated email drafts and clarification requests.

Mikko voice model (greeting, sign-off, tone, formality)
Phrase library with natural variation
Gmail API integration for draft creation
Bulk approve/reject workflows

Meeting Intelligence

Prepares contextual briefs and enriches them post-meeting with Read.AI transcripts.

7-day lookahead with 24h/1h alerts
Participant history and product context injection
Post-meeting enrichment from Read.AI webhooks
Action item extraction and triage correlation

Content Pipeline

Drafts social content from inspiration sources with engagement-based self-revision.

Multi-platform with Mikko/Ciel voice variants
7 content types (insight, case_study, technical, etc.)
Source reader fetches from YouTube, newsletters, blogs
Engagement analysis revises underperformers

Conversational Brain

Multi-turn chat with 24 intents, entity tracking, and multi-modal vision support.

Intent classification (LLM + 22 regex fallbacks)
Unified conversation memory across platforms
Image upload/paste with base64 vision pipeline
Ideation session continuation for brainstorming

Self-Evolution System

Ciel learns from corrections, recalibrates its behavior, and codifies patterns directly into its own source code.

1. Teach

User corrects via chat

Mikko corrects a classification or provides a new rule. Ciel stores it with scope and pattern.

→

2. Inject

Rules influence LLM prompts

Non-codified rules stay in classifier, product_mapping, and summarization prompts (including codify_pending while a PR is open). promptInfluenceCount tracks classifier injections.

→

3. Recalibrate

6h override analysis

Brain daemon analyzes 30-day override patterns. Adjusts voice model, goal priorities, and rhythm baselines.

→

4. Codify

CLI agent → PR → merge

At maturity, self-evolve enqueues a planned EU; ciel-evolution-controller opens the PR. T2 scopes await human merge; promoted scopes (e.g. product_mapping T4) auto-merge when gates pass. Rules enter codify_pending at pr_open until merge.

Scopestriage_classificationnoise_filterurgencyproduct_mappingsummarizationui_renderingdraft_formataction_logicnotification

Rule Lifecycle Example

Rule Stored

Created

pattern"Trip meetings are personal, not product-specific"

actionclassify_as_fyi

scopetriage_classification

appliedCount0

sourceuser_feedback

Trust Record: Confidence by Content Type

Code Implementation91%

Auto-PR creation with minimal revision

Triage Classification87%

Mostly autonomous signal routing

Email Drafts72%

Requires one-click approval

Social Posts54%

Revision common, growing confidence

The Journey of a Signal

Follow a single Jira ticket from arrival to shipped code. Every step fully autonomous.

Before

✗Manual triage across Gmail, Jira, Kayako, Calendar. Constant context switching overhead
✗Meeting prep done ad-hoc 5 minutes before the call
✗Clarification emails written manually for each ticket
✗Implementation specs lived in undiscoverable Notion docs
✗Social content created in batches, inconsistent cadence
✗No single view of cross-product dependencies

After

✓Signals auto-ingested every 5 minutes, classified with urgency + product tags
✓Meeting briefs generated 24h ahead with full participant/product context
✓Voice-calibrated drafts auto-generated, one-click approve to Gmail
✓Specs auto-generated from triage → auto-implemented → PR created
✓Content pipeline with engagement analysis and self-revision
✓Entity correlation graph maps all cross-product relationships

Signal Arrives

T+0

A Jira ticket update hits ciel-monitor during its 5-minute sweep across 7 integrated sources.

source: jira
type: ticket_update
product: CRM Pad
priority: medium

Classification

T+5 min

ciel-triage classifies the signal as spec_ready with urgency: review, injecting 3 learned rules into the LLM prompt.

status: spec_ready
urgency: review
partner: Acme Corp (resolved via domain rule)
learned_rules_injected: 3

Spec Generated

T+10 min

ciel-specs produces a technical implementation plan with problem statement, approach, file targets, and test strategy.

buildMode: auto
sections: [problem, approach, files, tests]
model: composer-2-fast
estimated_files: 3

Performance & Cost Design

A 5-tier model router ensures every LLM call uses the cheapest model that can do the job, from nano-tier intent parsing to code-tier implementations.

ciel-terminal

$ ciel status --verbose

Operational Mode: FULL (heartbeat 12s ago)

Active Daemons: 16/16 healthy

MODEL ROUTER

nano gpt-5.6-luna-none 10s intent, alerts

fast composer-2.5 30s triage, specs, posts

mid cursor-grok-4.6-high 120s questions, learning

power cursor-grok-4.6-high 120s ideas, instructions

code cursor-grok-4.6-high 300s implementations

Queue: interactive 0/2 | background 0/1

Two-Lane Queue: interactive (max 2) + background (max 1)

Instrumentation: model, tokens, duration, cost → MetricLog

Governance: weekly pricing + deprecation checks

$ ciel status

Mode: FULL | Daemons: 16/16

MODEL ROUTER

nano gpt-5.6-luna-none 10s

fast composer-2.5 30s

mid cursor-grok-4.6-high 120s

power cursor-grok-4.6-high 120s

code cursor-grok-4.6-high 300s

Queue: 0/2 int | 0/1 bg

16 Always-On Daemons

A nervous system of background processes: ingesting signals, classifying work, generating specs, and maintaining the correlation graph around the clock.

ciel-monitor

5 min

Ingests signals from 7 sources into unified model

INGmail, Calendar, Chat, Jira, Kayako APIs

OUTSignal rows, graph edges

LOOPdaemon-loop

ciel-triage

5 min

Classifies signals into actionable work items

INUnprocessed Signals (batch 50)

OUTTriageItems, correlations, notifications

LOOPdaemon-loop

ciel-clarify

5 min

Drafts clarification emails for ambiguous items

INTriageItems (needs_clarification)

OUTDraft (type: clarification)

LOOPcustom

ciel-specs

5 min

Generates technical specs from approved work

INTriageItems (spec_ready)

OUTSpec drafts, status → in_review

LOOPcustom

ciel-implementations

1 min

Spawns CLI agents to implement approved specs

INImplementation (pending), Spec

OUTPRs, test findings, status updates

LOOPdaemon-loop

ciel-posts

24h/30min

Generates and schedules social content

INPosts, sources, goal_model

OUTPost drafts, scheduling alerts

LOOPcustom

ciel-brain

Recalibrates behavior, generates digests and goals

INCielState, published posts, sources

OUTRecalibration, digest, daily summary

LOOPcustom

ciel-meeting-prep

15 min

Generates meeting briefs with participant context

INCalendar signals (7-day lookahead)

OUTMeetingBriefs, 24h/1h alerts

LOOPcustom

ciel-kb

10 min

Syncs knowledge base and discovers partners

INUnprocessed Signals

OUTKB updates, partner discovery

LOOPcustom

ciel-correlation

30 min

Maintains entity graph with decay, pruning, discovery

INEntityCorrelations, Signals, TriageItems

OUTDecayed/pruned edges, new discoveries

LOOPcustom

ciel-llm-governance

7 days

Weekly LLM cost and model status reports

INMetricLog, provider APIs

OUTLlmGovernanceReport, GChat summary

LOOPdaemon-loop

ciel-mcp

persistent

MCP tool server exposing 29 tools via JSON-RPC

INstdio JSON-RPC requests

OUTTool responses (DB + filesystem)

LOOPpersistent

ciel-heartbeat

30s

Pings Vercel to maintain operational mode

INCielState POST

OUTOperational mode heartbeat

LOOPpersistent

ciel-ngrok

persistent

Tunnel bridging Vercel webhooks to localhost

INInbound HTTPS traffic

OUTVercel ↔ localhost bridge

LOOPpersistent

ciel-web

persistent

Local Next.js server for brain proxy endpoint

INHTTP :3000 requests

OUTBrain processing responses

LOOPpersistent

ciel-migrate

one-shot

Schema sync on startup via Prisma db push

INprisma/schema.prisma

OUTDatabase schema updates

LOOPone-shot

Health Escalation Protocol

Healthy

0 errors

→

Alert

1–9

→

Reconnect

10–49

→

Backoff

50–199

→

Stop

200+

Engineering Patterns

Production-grade patterns built for reliability, observability, and autonomous operation.

Optimistic Locking (CielState)

Every state write checks version, retries on conflict with linear backoff.

async function setCielState<K>(key: K, value: V) {
  for (let attempt = 0; attempt < 3; attempt++) {
    const current = await prisma.cielState.findUnique({
      where: { key },
    });
    const updated = await prisma.cielState.upsert({
      where: { key, version: current?.version ?? 0 },
      update: { valueJson: value, version: { increment: 1 } },
      create: { key, valueJson: value, version: 1 },
    });
    if (updated) return updated;
    await sleep(10 * (attempt + 1));
  }
}

Model Router (5-Tier)

Maps each of 24 intents to the cheapest model tier capable of handling it.

const TIER_DEFAULTS = {
  skip: { model: 'gpt-5.6-luna-none',       timeout: 10_000  },
  nano: { model: 'gpt-5.6-luna-none',       timeout: 10_000  },
  fast: { model: 'composer-2.5',            timeout: 30_000  },
  mid:  { model: 'cursor-grok-4.6-high',    timeout: 120_000 },
  power:{ model: 'cursor-grok-4.6-high',    timeout: 120_000 },
  code: { model: 'cursor-grok-4.6-high',    timeout: 300_000 },
};

function routeIntent(intent: string): RouteConfig {
  return {
    ...TIER_DEFAULTS[INTENT_TIER_MAP[intent]],
    lane: isInteractive(intent) ? 'interactive' : 'background',
    workspace: INTENT_WORKSPACE_MAP[intent],
  };
}

Agent Queue (Two-Lane)

Ensures interactive chat stays responsive while daemons process in the background.

const LANES = {
  interactive: { max: 2, queue: [] },
  background:  { max: 1, queue: [] },
};

async function enqueue(lane: Lane, task: AgentTask) {
  if (running[lane] < LANES[lane].max) {
    running[lane]++;
    try { return await task(); }
    finally { running[lane]--; drain(lane); }
  }
  return new Promise((resolve) => {
    LANES[lane].queue.push(() => resolve(task()));
  });
}

Entity Correlation Graph

Typed edges between any two entities with confidence scoring and temporal decay.

interface EntityCorrelation {
  sourceType: EntityType;
  sourceId: string;
  targetType: EntityType;
  targetId: string;
  relationship: RelationType;
  confidence: number;   // 0-1, decays over time
  decayScore: number;   // exponential decay (0.99^days)
  lastVerified: Date;
}

type EntityType =
  | 'signal' | 'triage_item' | 'partner'
  | 'meeting' | 'spec' | 'implementation'
  | 'idea' | 'kb_entry' | 'product';

Non-blocking Webhook

Return 200 immediately, process in background. Prevents platform retry storms.

export async function POST(req: Request) {
  const body = await req.json();

  after(async () => {
    await processCielMessage(body.text, {
      platform: 'gchat',
      images: attachedImages,
    });
  });

  return NextResponse.json({ ok: true });
}

Daemon Health Escalation

Graduated response from retry → backoff → stop with GChat alerts at each stage.

async function runDaemonLoop(opts: DaemonLoopOptions) {
  let consecutiveErrors = 0;
  while (true) {
    try {
      await opts.cycle();
      consecutiveErrors = 0;
      if (cycleCount % 5 === 0) writeHeartbeat('healthy');
    } catch (err) {
      consecutiveErrors++;
      if (consecutiveErrors <= 9)  alertDaemonError(err);
      if (consecutiveErrors === 10) prisma.$disconnect();
      if (consecutiveErrors >= 50)  intervalMs = 300_000;
      if (consecutiveErrors >= 200) {
        writeHeartbeat('stopped');
        return;
      }
    }
    await sleep(intervalMs);
  }
}

CI/CD

Prisma validate → lint → tsc → vitest → next build

Type-Safe

Strict TypeScript + Prisma-generated types end-to-end

Edge-First

All routes Edge-compatible (crypto.subtle, no Node APIs)

Zero Docker

Vercel + PM2 + Supabase. No containers to manage