Skip to main content

​
Overview

Alfred manages 26 distinct record types organized into five layers: Standing Entities (8) for the stable elements of your world, Activity Records (9) for what happens, Execution Types (1) for how work gets done, Learning Types (5) for the deeper knowledge the Distiller surfaces, and Intuition Types (3) for the patterns Alfred learns from how you work.

​
The Matter / Errand / Triage lifecycle

Three record types form the core execution lifecycle:
  • Matter — an ongoing concern that groups related errands (e.g., “Hetzner migration,” “Q2 launch”). Matters persist until resolved.
  • Task (Errand) — a discrete unit of work belonging to a matter. The owner field determines who acts: alfred means the Task Runner executes automatically; human means the item appears on your dashboard for you to handle.
  • Triage — an item Alfred couldn’t confidently classify. Triage items surface on your dashboard for human review. When you reclassify them, the routing decision feeds back into the intuition system.

​
Stream events as record sources

Stream events from Gmail, Notion, Omi, and other integrations create activity records automatically. An incoming email becomes a conversation record; a Notion page update becomes a note; an Omi recording becomes a session. The Event Processor classifies each event and the Curator structures it — no manual sharing required.

​
Standing Entities

Records representing the people, organizations, and resources in your world.
What it represents: Individuals, contacts, team members, or stakeholders.When it’s created: The Curator creates person records when people are mentioned in your content — meeting attendees, email contacts, team members referenced in notes.Example: You share standup notes mentioning “Alice reviewed Bob’s PR.” Alfred creates person records for Alice and Bob (or updates them if they already exist) and links both to the conversation.Status values: active, inactiveKey fields: name, status, org (link to organization), email, tags
What it represents: Companies, teams, departments, or organizational entities.When it’s created: The Curator creates org records when companies or teams are mentioned in your content.Example: Meeting notes reference “the Acme Corp partnership.” Alfred creates an org record for Acme Corp and links it to relevant people and projects.Status values: active, inactiveKey fields: name, status, website, location, tags
What it represents: Projects, initiatives, or multi-task efforts.When it’s created: The Curator creates project records when initiatives or efforts are discussed in your content.Example: Standup notes mention “Platform v2 migration is on track.” Alfred creates a project record linked to the people working on it and any related tasks.Status values: active, paused, completed, abandoned, proposedKey fields: name, status, owner (link to person), tags
What it represents: Physical or virtual locations.When it’s created: The Curator creates location records when places are mentioned in meetings, events, or notes.Example: “The offsite will be at the SF Conference Center.” Alfred creates a location record and links it to the event.Status values: active, inactiveKey fields: name, status, tags
What it represents: Accounts, subscriptions, or service credentials.When it’s created: The Curator creates account records when services or subscriptions are discussed.Example: Notes mention “our AWS Production account needs a billing review.” Alfred creates an account record linked to the relevant people and tasks.Status values: active, suspended, closed, pendingKey fields: name, status, owner (link to person), tags
What it represents: Physical or digital assets and resources.When it’s created: The Curator creates asset records when specific resources are discussed.Example: “The production database server needs a memory upgrade.” Alfred creates an asset record linked to the task and owner.Status values: active, retired, maintenance, disposedKey fields: name, status, owner (link to person), tags
What it represents: Defined processes, procedures, or workflows.When it’s created: The Curator creates process records when operational procedures are described.Example: “We need to update the deployment pipeline to include staging.” Alfred creates a process record and links it to the project and people involved.Status values: active, proposed, design, deprecatedKey fields: name, status, owner (link to person), tags
What it represents: An ongoing concern that groups related errands — a thread of activity Alfred tracks on your behalf. The Hetzner matter, the invoice matter, the onboarding matter.When it’s created: The Curator creates matter records when a recurring concern is identified across multiple inputs, or when you explicitly tell Alfred to track something as an ongoing matter.Example: Several emails and tasks relate to migrating infrastructure to Hetzner. Alfred groups them under a matter record, linking related errands, people, and decisions so the full picture is always one click away.Status values: active, resolved, archivedKey fields: name, status, related (links to grouped records), tags

​
Activity Records

Records capturing events, work, interactions, and execution results.
What it represents: Meetings, discussions, or dialogue threads.When it’s created: The Curator creates conversation records from meeting notes, email threads, or chat exports you share.Example: You share standup notes. Alfred creates a conversation record for the meeting, links it to all participants, and creates separate records for tasks and decisions mentioned.Status values: active, waiting, resolved, closed, archivedKey fields: subject, status, participants (links to people), tags
Conversations use subject instead of name as their title field.
What it represents: Observations, research, or freeform content.When it’s created: The Curator creates note records for general content that doesn’t fit neatly into a more specific type.Example: You share a brainstorm document. Alfred creates a note record and links it to the relevant projects and people mentioned.Status values: draft, active, review, finalKey fields: name, status, tags
What it represents: A unit of work — an errand to be carried out, either by Alfred or by you. Tasks are the execution backbone of the Kinetic layer.When it’s created: The Curator creates tasks from action items in your content. Instincts with execution blocks create tasks automatically when Judgment matches them. You can also create tasks directly from your dashboard.Example: An instinct fires on a new vendor invoice. Judgment creates a task: “Process invoice from Acme Corp,” assigns it to Alfred at tier 1, and links the skill skill/invoice-processing as the methodology. The Task Runner picks it up, follows the skill, and marks it done — creating a ledger entry with what happened.Status values: queued, active, blocked, done, cancelledKey fields: name, status, owner (alfred or human), tier (1–3), skill_entry (link to skill), matter (link to matter), source_event, source_instinct, agent_id, budget_turns, requires_approval, depends_on, blocked_by, tags
Tasks owned by alfred are executed automatically by the Task Runner. Tasks owned by human appear on your dashboard for you to handle. See the Kinetic layer for how execution works.
What it represents: An item Alfred couldn’t confidently classify — it needs your review before it can be properly filed.When it’s created: When the Curator encounters content it can’t confidently route to a specific record type. Rather than guessing, Alfred sets it aside as a triage item for your attention.Example: You share a screenshot with no clear context. Alfred can’t tell if it’s a task, a note, or part of a conversation — so it creates a triage record and surfaces it on your dashboard for review.Status values: unprocessed, reviewed, resolvedKey fields: subject, status, tags
What it represents: A factual record of what happened when an errand completed. Timestamped and traceable — the paper trail for Alfred’s work.When it’s created: The Task Runner creates a ledger entry whenever a task reaches done status. It captures what was accomplished, which artifacts were produced, and how the work connected to the broader matter.Example: After processing the Acme Corp invoice, Alfred writes a ledger entry: “Extracted amount ($4,200), due date (April 15), created payment reminder task. Linked to matter/acme-billing.”Consequentials: Ledger entries can spawn follow-up errands — called consequentials. When a completed task reveals additional work (e.g., “invoice processed, but payment reminder needs scheduling”), the Task Runner creates a new errand linked to the same matter. This chains work naturally without manual intervention.Status values: (no status constraint)Key fields: name, task (link to completed task), matter (link to matter), artifacts, consequentials (links to follow-up tasks), tags
What it represents: One-time events, conferences, launches, or occurrences.When it’s created: The Curator creates event records when specific scheduled occurrences are mentioned.Example: “The annual team offsite is April 10th.” Alfred creates an event record with the date, location, and participants linked.Status values: (no status constraint)Key fields: name, date, location, participants (links to people), tags
What it represents: Time-bounded activity periods or work blocks.When it’s created: Created automatically by the Session Tracker, which groups related vault activity into time-bounded sessions every 5 minutes. Sessions are also created by the Curator when focused work periods are described.Example: Alfred detects 4 vault records created within 20 minutes about database migration. It groups them into a session with the topic summary ‘Database migration planning’ and links to all member records.Status values: active, paused, finishedKey fields: name, status, topic_summary, idle_minutes, participants, records (links to session members), tags
What it represents: Raw items in the inbox waiting to be attended to.When it’s created: Created when content is shared with Alfred, before the Curator attends to it.Example: You upload a document via the API. An input record tracks it until the Curator creates structured records from it.Status values: unprocessed, processed, deferredKey fields: subject, status, tags
Inputs use subject instead of name as their title field.
What it represents: Execution runs, operations, or batch operations.When it’s created: Created to track operational runs and batch work.Status values: active, completed, blocked, cancelledKey fields: name, status, outputs (links to results), tags

​
Execution Types

Records that define how work gets done.
What it represents: A plain-English methodology file that teaches Alfred how to approach a type of work. Skills describe reasoning patterns, not data — they’re the “how” behind task execution.When it’s created: You author skill files when you want Alfred to follow a specific methodology for a recurring type of work. Skills can also be generated by the Distiller when it identifies a repeatable process in your vault.Example: You write a skill called “Invoice Processing” that describes how to extract amounts, validate line items, and create payment reminders. When a task references this skill, the Task Runner follows the methodology step by step.Status values: (no status constraint)Key fields: name, domain (input_processing, execution, propagation, preference, process), tier (1–3), related_skills (links to other skills), tags
Skill files live in the skill/ folder of your vault. They’re plain English — no code required.

​
Learning Types

Records created by the Distiller that capture deeper knowledge surfaced from your vault.
What it represents: Assumptions lurking in your records that haven’t been explicitly validated.When it’s created: The Distiller surfaces implicit assumptions when analyzing your conversations, decisions, and project records.Example: From project discussions, the Distiller surfaces: “We’re assuming users prefer mobile-first design — this hasn’t been validated with data.”Status values: active, challenged, invalidated, confirmedKey fields: name, status, based_on (source records), challenged_by, confirmed_by, invalidated_by, tags
What it represents: Choices that were made, along with the reasoning behind them.When it’s created: Both the Curator (from explicit mentions) and the Distiller (from implicit context) create decision records.Example: Meeting notes mention “Decision: use token bucket algorithm for rate limiting.” Alfred captures the decision, who approved it, and what it was based on.Status values: draft, final, superseded, reversedKey fields: name, status, based_on (source records), approved_by, tags
What it represents: Boundaries, limitations, or constraints you’re operating under.When it’s created: The Distiller identifies constraints from project plans, conversations, and decisions.Example: The Distiller surfaces: “Must support legacy API until Q3 due to existing client contracts.”Status values: active, expired, waived, supersededKey fields: name, status, based_on (source records), governed_by, tags
What it represents: Conflicts or contradictions found across different records.When it’s created: The Distiller identifies contradictions when analyzing records that contain conflicting information.Example: The Distiller finds: “The Q2 launch goal conflicts with the security audit requirement, which needs 6 weeks and hasn’t started.”Status values: unresolved, resolved, acceptedKey fields: name, status, based_on (conflicting records), tags
What it represents: Synthesized insights that connect patterns across multiple records.When it’s created: The Distiller creates synthesis records when it finds meaningful patterns across your vault.Example: The Distiller connects dots: “Both the Q1 Launch and Platform Redesign projects identified onboarding as a user retention blocker — suggesting a shared improvement opportunity.”Status values: draft, active, supersededKey fields: name, status, based_on (source records), supports, tags
Learning types are automatically surfaced by the Distiller. While you can create them via the API, they’re typically generated automatically from your existing records.

​
Intuition Types

Records created by Alfred’s intuition system as it learns your preferences and routing patterns. See the Intuition guide for how these work together.
What it represents: A record of why something was routed a certain way — Alfred observed your preference.When it’s created: Automatically when you route an input through conversation, or when Alfred’s judgment system routes something autonomously. Also created when you add a routing_hint to a vault record.Example: You tell Alfred to file a vendor email under the client onboarding project. Alfred creates an observation recording the input type (email), the routing decision (project/client-onboarding), and the signals that characterized the input (sender domain, keywords, attachment type).Status values: unprocessed, processed, invalidKey fields: input_type, input_source, input_ref, routing_decision, reasoning, signals, confidence, routed_by
What it represents: A learned pattern distilled from multiple observations — an instinct Alfred has developed for how to handle a recurring type of input.When it’s created: During nightly reflection, when Alfred identifies at least 3 observations of the same routing pattern. Instincts are also updated, merged, or deprecated during reflection as new evidence accumulates.Example: After observing you route several vendor invoices to the same process, Alfred creates an instinct: “Emails from vendor domains containing invoice keywords and PDF attachments should be routed to process/invoice-processing.”Status values: active, proposed, deprecated, mergedKey fields: domain, observation_count, discretion_threshold, signals, matching_weights, routing_destination, last_matched, total_matches, total_escalations, based_on
What it represents: A report from Alfred’s nightly reflection process — what it reviewed, what patterns it found, and what changes it made to its instincts.When it’s created: Every night at 2am during the reflection process. One reflection report per night (only created when there are new observations to review).Example: “Reviewed 8 new observations. Created 1 new instinct (Hiring Pipeline Updates). Strengthened 2 existing instincts (Vendor Invoices, Meeting Notes). No deprecations.”Status values: (no status constraint)Key fields: observations_reviewed, instincts_created, instincts_updated, instincts_deprecated, reasoning
Intuition types are managed automatically by Alfred’s learning system. Observations are captured from your routing decisions, instincts are refined during nightly reflection, and reflection reports document what Alfred learned. See the Intuition guide for the full picture.

​
Naming conventions

  • Type identifiers use lowercase, singular form (e.g., person, not Person or people)
  • Record names use title case with spaces (e.g., “Alice Smith”)
  • Three types (conversation, input, triage) use subject as their title field instead of name
Use the GET /api/v1/vault/schema endpoint to retrieve the complete, up-to-date schema programmatically — including all 26 types and their valid statuses.