Flagship · Agentic AI system

Otto: an autonomous chief of staff for product managers.

Otto reads everything that comes at me (email, Slack, support tickets, meetings, planning sheets), decides the few things that actually need me, drafts my responses in my own voice, runs my weekly plan, and gives me one calm place to work from. It never sends anything on its own, and it gets better every day by learning from what I actually do.

The core promise: reclaim the operational hours, so I can spend time on the product thinking only I can do.
What
A personal AI operations layer that triages inbound, drafts replies, and manages my week.
How it runs
A scheduled agent sweeps every 2 hours (12pm to 12am IST) into a shared datastore that powers a web hub.
Autonomy
Drafts everything, sends nothing. Every outbound action waits for my one click.
The problem

Most of my day was not product work. It was operational drag.

I am a PM, but the job kept getting buried under the scan: reading everything just to find the few things that needed me. The deep product work kept getting pushed to "later."

01
Email. A daily stream of reports, digests, and threads I am only cc'd on. Only a few actually need me, but I still had to read through to find them.
02
Slack. Channels and DMs always open. The one message where I am genuinely needed gets buried in the noise and missed.
03
Support tickets. They pile up, and a handful need a decision from me: a comment to dev, or a new sprint item. Finding those few was a daily manual scan.
04
One shared planning sheet, ten tabs. Weekly plan, product to-dos, client issues, backlog, CEO feedback. Keeping my own priorities straight across all of it was a chore.
What Otto is

A single agent with a simple loop, on a schedule.

Every run, it senses all my inbound, decides what needs me, drafts what it can in my voice, folds new work into my plan, writes everything to one datastore, and learns from what I sent since the last run. Built on a hard rule: Otto never sends. It only ever stages drafts. The final send is always my click, in the real tool.

01
Sense
Read every channel
02
Triage
Needs me / FYI / noise
03
Draft
In my voice
04
Plan
Fold into my week
05
Surface
One Action Hub
06
Learn
Converge on me
What it does

Six jobs, one pass.

// sense

Reads everything, in one pass

Gmail threads, Slack DMs and mentions, Freshdesk tickets (discovered via email, enriched via API), meeting transcripts from Arali matched to my calendar, and all ten tabs of the team planning sheet.

// triage

Turns noise into signal

Every item is classified needs me / FYI / noise and bucketed. Sales Inbound (my area) ranks highest, then customers, then leadership. Each item gets a response deadline so nothing ages past my SLA.

// draft

Drafts in my voice, knows when not to

A voice profile learned from my real sent messages: short, direct, bullets, correct register (polished English for customers, casual Hinglish for internal Slack). A confidence gate means it never fakes a weak draft.

// plan

Runs my week

Tasks pulled from emails, Slack, tickets, meeting action items, and my rows across every sheet tab, into a Notion-style board with a "do this now" order: sprint work leads, but a breached deadline jumps the queue.

// surface

One Action Hub

Today, Triage, Needs Your Input, Tasks, Tickets. Each card is self-contained: a plain-language summary, a timeline, the key facts, and the draft, all inline, so I rarely open the original tool.

// learn

Gets better every day

The piece that makes it a chief of staff, not a triage bot. A correction becomes a standing rule the agent applies everywhere, from then on. (Full detail below.)

The part I care about most

A self-learning loop: teach it once, not every time.

Most AI assistants are static: as good on day 100 as day 1, and you keep making the same corrections forever. Otto is built to converge on me over time. A correction is not a throwaway edit. It becomes a standing rule applied everywhere.

It learns from four signals

signal 01
Explicit corrections

"Use bullets," "I own Sales Inbound." Written straight into memory and honored immediately, on existing drafts and all future ones.

signal 02
Draft-vs-sent diffs

It compares what I actually sent to what it had staged. Every wording or tone change becomes a voice rule. Drafts drift toward sounding exactly like me.

signal 03
Exemplars it could not do

When it hits the confidence gate and I handle it myself, it captures how I handled it. Next time, that situation is draftable. The bottleneck shrinks.

signal 04
Judgment calls

For debatable tickets (bug for dev, or feature for the sprint?) it records its guess and my actual decision, and learns my line on a hard distinction.

▸ A real example, from the live system

I told Otto two things in one message: prefer bullets, and I own Sales Inbound. Within the same session it:

  1. wrote two rules into its voice_profile (bullets, and my role, weighted high),
  2. logged the correction in learnings,
  3. re-generated the three drafts already sitting in my Hub into clean bulleted form, and
  4. started ranking anything touching Sales Inbound highest in triage.

I taught it once. It applied the lesson to existing work and everything after. That is the whole idea.

How it is built

Brain, spine, face: cleanly separated.

The same datastore serves a scheduled agent and an interactive app. That separation is the whole architecture.

The Sweep · the brain
a scheduled Claude agent running a versioned playbook, every 2 hours
Gmailconnector
Slackconnector
FreshdeskREST API
Arali + Cal + Sheetconnectors · 10 tabs
↓   triage · draft (voice + personas) · plan · learn   ↓
Datastore · the spine
Turso / SQLite: items, drafts, tasks, sprints, voice_profile, exemplars, learnings, ticket_decisions
↓   reads / approvals write back   ↓
Action Hub · the face
Next.js: Today · Triage · Needs Input · Tasks board · Tickets
↓   I approve / edit / reject   ↓
Native in-thread drafts
in Gmail / Slack / Freshdesk. I click send, always.
LayerWhat it isBuilt with
BrainA versioned playbook the scheduled agent follows each runClaude (Max), a Markdown workflow spec, persona files
HandsReads inbound and stages draftsclaude.ai connectors (Gmail, Slack, Calendar, Drive, Arali MCP) + Freshdesk REST API
SpineOne datastore the agent and hub shareTurso (libSQL / SQLite) over its HTTP API
FaceThe Action Hub web appNext.js (App Router), server components + API routes, plain CSS
MemoryLearned voice, exemplars, corrections, ticket callsDatastore tables the sweep reads before every draft
ClockThe 2-hour cadenceA scheduled cloud routine
Why it is safe to trust

Guardrails, by design.

This is wired into my real accounts. The defaults are chosen so nothing embarrassing or wrong can go out on its own.

Never sends

The agent only creates drafts. Sending is always a human click in the real tool.

In-thread only

Drafts are replies on the existing thread, never new messages, so nothing goes out of context.

Confidence gate

Low-confidence situations become "needs your input" with the exact gap, never a plausible-but-wrong draft.

Read-only where it should be

The shared team sheet is read every run and never written back.

Honest status

What is live vs what is next.

It runs, on my real inbox, today. Here is exactly where the line sits, because a portfolio that oversells is worse than one that is precise.

● Live and working
  • The datastore, schema, and zero-dependency write path
  • The Action Hub: Today, Triage, Needs Your Input, Tasks board, Tickets, with approve / edit / reject persisting
  • Reads across Gmail, Slack, the Freshdesk API, and all ten sheet tabs
  • Voice profile, drafting in my style, and the confidence gate
  • The learning store: corrections captured and applied live; ticket guesses logged awaiting my ruling
  • Prioritization with SLA guardrails
What this demonstrates

The point of the project.

01
Problem framing from lived pain: three concrete, measurable operational problems, designed to specific outcomes ("nothing that needs me waits more than a few hours").
02
AI product design, not just prompting: an agent with a clear loop, a confidence gate, human-in-the-loop review, and a learning system, including honest handling of when the agent should defer.
03
Systems thinking: a clean split of brain, spine, and face, so one datastore serves both a scheduled agent and an interactive app.
04
Taste and craft: a deliberate design language and interaction model (self-contained cards, Notion-style editing) rather than a default dashboard.
05
Judgment under constraints: shipping within a "no LLM API keys, use existing connectors" rule, fixing real issues (a serialization bug, a workbook with ten tabs when one was being read), and choosing safe defaults.
06
Shipping: it runs, on my real inbox, today.
Claude (Max) claude.ai connectors Freshdesk API Turso / libSQL Next.js (App Router) plain CSS scheduled routine