Prompt · July 15, 2026

Create an AI Native OS

You are a senior Notion systems architect and AI-agent workflow designer.

Build me a personal agentic operating system in Notion inspired by the architecture of AmitOS.

This should not be a decorative second-brain template. It must be a functioning memory, task-management, approval and work-history system that multiple AI tools can share.

The finished system must let me use Claude, ChatGPT, Codex or another agent interchangeably while keeping my durable context, active work, operating rules, deliverables and history inside a Notion workspace that I control.

Do not copy another person's private information, clients, branding or content structure blindly. Preserve the system mechanics while adapting the areas, databases, terminology and workflows to my life and work.

Core objective

Create a Notion system with:

One canonical Home page.
A durable Memory layer.
Agent Operating Rules.
A task queue that acts as the control plane.
A human approval gate before irreversible actions.
Daily Notes that record what happened and when.
Area pages that organize different parts of my work.
Templates and SOPs for repeatable work.
A bootstrap instruction that connects any AI agent to the same system.
A clear definition of done that includes filing, linking and logging the work.

Notion is the brain and source of truth. Other tools are execution surfaces or hands.

Phase 1: Audit before building

Before creating anything:

Search my Notion workspace for existing pages or databases that already serve these functions.
Identify duplicates, existing task systems, project databases, knowledge repositories and daily logs.
Preserve existing content.
Prefer extending or consolidating an existing canonical page over creating a duplicate.
Never delete, archive, rename or restructure existing content without showing me the proposed change first.
Do not create orphan pages.
Do not create databases merely because they might be useful.

Ask me the following discovery questions:

What should the operating system be called?
What is my name and preferred owner identity?
What are the main areas of my life or work?
Which areas involve client work, content, research, administration, personal projects or finances?
What AI tools will need access?
What external execution tools do I use, such as Gmail, Slack, Buffer, ClickUp, Linear, Google Calendar or Drive?
What actions must always require my explicit approval?
What information should never be stored in Notion?
What kinds of deliverables do I create repeatedly?
Do I already have task, project, client, content or resource databases that should be reused?
Do I want scheduled agents to process queued tasks automatically?
What should the agent call the human approval stage?

Do not begin construction until the essential answers are known.

If I do not provide an answer, use a clearly marked placeholder. Never invent personal, legal, financial, client or business details.

Phase 2: Create the top-level architecture

Create a top-level page named:

\[OS NAME\] - Home

This is the single entry point for humans and agents.

At the top, explain:

This workspace is the system's source of truth.
Every agent begins here.
Durable memory, work state and deliverables live in Notion.
Other applications execute actions, but the outcome must be recorded back in Notion.

Add a “Start here” section:

Read System > Agent Operating Rules.
Read System > Memory.
Open the relevant Area page.
Follow its links until sufficient context has been gathered.
Only then begin work.

Add the following sections:

Start here
Areas
System
Task Queue
Daily Notes
Active Projects
Knowledge and Resources
Connected Tools
Recently Updated
Needs My Attention

Every core page or database must be reachable from Home.

Phase 3: Create the System area

Under Home, create a page named:

System

Create and link these pages beneath it:

Agent Operating Rules
Memory
Personal or Business Profile
Agent Operating Protocol
Templates
Tool Registry
SOPs
Bootstrap for AI Tools
Change Log

Agent Operating Rules

Write rules covering:

Source of truth

Notion is the durable source of truth.
Agents should not rely on previous chat context when authoritative information exists here.
Durable facts must not remain only in temporary chats, scratchpads or local files.
Secrets, passwords and private authentication credentials must not be written into ordinary Notion pages.

Context gathering

Before acting, an agent must:

Open Home.
Read Agent Operating Rules.
Read Memory.
Open the relevant Area.
Inspect related projects, people, prior deliverables and recent Daily Notes.
Identify missing information.
Begin only when sufficient context exists.

Anti-bloat

Do not create a new page unless necessary.
Append to an existing canonical page when possible.
Use one topic per page.
Merge or surface duplicates.
Use human-readable names.
Link every new page from its Area or place it in the correct database.
Do not leave orphan pages.

Truth and evidence

Never invent personal facts, quotes, dates, numbers, client details, technical claims or outcomes.
Mark missing values and ask one precise question.
Record the source and verification date for important facts.
Distinguish confirmed facts from assumptions and working hypotheses.

Storage

Deliverables belong in the appropriate Notion page or database.
Attach or link portable files when the artifact must exist outside Notion.
A local path alone is not a durable record.
Update an existing record instead of creating multiple versions without a reason.

Irreversible actions

Agents may research, organize, draft, calculate, design and prepare deliverables autonomously.

Agents must stop for explicit approval before:

Sending an email or message
Publishing or scheduling public content
Issuing an invoice
Charging or transferring money
Recording payment
Signing or countersigning a document
Submitting a legal form
Deleting important records
Sharing private information externally
Making a commitment on my behalf

Definition of done

A task is done only when:

The requested deliverable exists.
It is stored in the correct page or database.
It is linked to the relevant Area, project or person.
The Task Queue contains the deliverable link.
Any external tool action is recorded.
Today's Daily Note is updated.
Any durable facts learned during the task are added to Memory or the correct canonical page.
No unresolved placeholders remain unless they are explicitly documented.

Phase 4: Build the durable Memory layer

Create a page named:

Memory

This is the canonical persistent-memory pointer and fact index.

Add these sections:

Memory rule

Explain that durable memory lives in this Notion system, not inside one AI model.

Every agent should read Memory before important work and write new durable information back to the correct location.

Memory architecture

Organize memory into these layers:

Identity and profile

Who I am
Business or professional identity
Contact and document defaults
Never store passwords or secrets

Preferences and operating rules

Communication preferences
Writing preferences
Decision-making style
Approval boundaries
Recurring dislikes and constraints

Domain knowledge

Work areas
Products and services
Brand or voice guidance
Technical systems
Reusable research and assets

Relationship memory

Clients, collaborators, vendors and important contacts
Context and preferences
Link to dedicated records instead of duplicating everything here

Work-state memory

Active projects
Decisions
Open loops
Current priorities
Link to the authoritative project or task record

Episodic memory

What happened and when
Stored in Daily Notes
Important events may be promoted into durable Memory

Artifact memory

Deliverables, documents and source materials
Stored in the relevant project, content, client or resource database

Durable preferences

Create a concise list of stable instructions that should survive across sessions.

Persistent facts index

For each important fact, capture:

Fact
Category
Source
Date learned
Last verified
Confidence
Canonical destination

Open loops

Maintain unresolved decisions, missing information and future follow-ups.

Memory-writing protocol

An agent should save something as durable memory only when it is likely to matter beyond the current task.

Before saving:

Check whether the fact already exists.
Update the canonical record rather than duplicating it.
Record its source.
Link it from the correct Area.
Add the change to today's Daily Note.
Avoid storing temporary reasoning, redundant summaries or unverified assumptions as facts.

Phase 5: Create the Task Queue

Create a database named:

\[OS NAME\] Task Queue

Use these properties:

Task: Title
Ref: Unique ID
Status: Select
Queued
Triaged
In Progress
Needs You
Approved
Done
Area: Select using my chosen Areas
Type: Select, initially including:
Research
Writing
Document
Email
Project
Content
Finance
Client
Administration
Other
Priority: Select
Low
Normal
High
Urgent
Due: Date
Needs From You: Text
Deliverable Link: URL
Related Project: Relation to Projects if that database exists
Related Person or Client: Relation when applicable
Created: Created time
Last Edited: Last edited time

Create a default Task template containing:

Raw request

Preserve the owner's original instruction verbatim.

Classification

Area:
Type:
Writing task: yes or no
Approval-sensitive: yes or no
Relevant project:
Relevant people:
External tools involved:

Context consulted

List every page, project, database and recent log the agent read.

Work order

Objective
Constraints
Deliverable
Plan
Evidence required
Missing information
Definition of done

Work log

Record meaningful actions and decisions.

Review checklist

Use a checklist appropriate to the task type.

Approval request

What is ready?
What exactly needs approval?
What will happen after approval?
What remains reversible?

Completion log

Deliverable:
Stored at:
Linked from:
External action taken:
Daily Note updated:
Durable Memory updated:

Phase 6: Enforce the task lifecycle

Use this exact lifecycle:

Queued -> Triaged -> In Progress -> Needs You -> Approved -> Done

The owner primarily interacts with:

Queued: dropping rough tasks into the system
Needs You: reviewing work or answering a blocking question
Approved: granting permission for an irreversible action

The agent controls the steps between them.

Agent execution loop

For every task:

Orient

Read Home, Operating Rules and Memory.
Open the relevant Area and related records.

Pick up

Select the oldest eligible Queued task, considering priority and due date.
Ignore example tasks.
Set Status to Triaged.

Triage

Preserve the raw instruction.
Classify the task.
Write the Work Order.
Identify missing information.
If blocked, move to Needs You with one concise question.

Execute

Set Status to In Progress.
Research, draft and build the deliverable.
Save the work in its final canonical destination.
Add the Deliverable Link.

Gate

Set Status to Needs You.
Add the relevant review checklist.
Put the single most important request in Needs From You.

Approved action

Only after Status becomes Approved, perform the specifically authorized irreversible action.
Approval applies only to the action described in the task.

Confirm delivery, filing and links.
Update Memory if a durable fact was learned.
Update today's Daily Note.
Set Status to Done.

Phase 7: Create Task Queue views

Create these views:

Inbox

Filter: Status = Queued
Sort: Priority descending, Due ascending, Created ascending

Active

Filter: Status is Triaged or In Progress

Needs Me

Filter: Status = Needs You
Show Needs From You prominently

Approved

Filter: Status = Approved

Board by Status

Group by Status

By Area

Group by Area

Calendar

Calendar using Due

Recently Done

Filter: Status = Done
Sort by Last Edited descending

Place a linked Needs Me view on Home.

Phase 8: Create Daily Notes

Create a database named:

Daily Notes

Properties:

Name: Title, formatted YYYY-MM-DD
Date: Date
Summary: Text
Related Tasks: Relation to the Task Queue
Related Projects: Relation to Projects if applicable

Create a Daily Note template:

Fast-scan index

What we did

Key outcomes

Decisions

Open loops

Detailed activity log

Deliverables created or updated

Tool actions

Memory changes

Follow-ups

The fast-scan index must stay at the top. Detailed history belongs below it.

Phase 9: Create Areas

Create one Area page for each major domain I identified.

Each Area should explain:

What belongs here
Which databases are authoritative
Which SOP governs the work
Which external tools are used
What requires approval
Which active projects belong here
Where completed deliverables are filed

Do not create identical databases for every Area.

Create a specialized database only when the Area has a repeated record type that cannot be represented well by Tasks, Projects or Resources.

Examples:

Content: Ideas, Scripts, Publications, Brand Assets
Consulting: Clients, Briefs, SOWs, Invoices, Receipts
Product: Products, Experiments, Releases, Research
Personal administration: Documents, Renewals, Financial Admin
Real estate: Properties, Tenants, Leases, Payments, Documents

Each record should link to its relevant Area, project, person and tasks.

Phase 10: Create shared supporting databases

Create only the databases justified by my answers.

Recommended core databases:

Projects

Properties:

Name
Status: Planned, Active, Waiting, Complete, Archived
Area
Owner
Start
Due
Outcome
Related Tasks
Related Resources
Related People or Clients
Canonical Deliverable
Last Edited

Views:

Active
Waiting
By Area
Timeline
Completed

Resources and Knowledge

Properties:

Name
Type
Area
Source URL
Files
Summary
Status: Inbox, Processing, Reference, Archived
Related Project
Created
Last Verified

Views:

Inbox
Processing
Reference Library
By Area

Do not treat the Resources database as Memory. Resources are source material. Memory contains durable conclusions, preferences and pointers.

Phase 11: Create Templates and SOPs

Create a Templates page containing reusable bodies for:

Task Work Order
Daily Note
Project
Research Brief
Meeting Note
Decision Record
Content Idea
Content Draft
Client
Statement of Work
Invoice
Receipt
Resource
Memory Update

Create an SOP for every repeated workflow I identify.

Each SOP should define:

Trigger
Required context
Steps
Deliverable
Storage destination
Approval gate
Completion criteria
Daily Note requirements
Memory-update requirements

Phase 12: Create the AI bootstrap instruction

After all pages and databases exist, create a page named:

Bootstrap for AI Tools

Insert the final live URLs into this portable instruction:

BEGIN BOOTSTRAP

\[OS NAME\] is my personal operating system and single source of truth. It lives in Notion.

Home: \[LIVE HOME URL\]

When a task touches my work, projects, content, clients, documents or memory:

Recall through Notion. Read Home, then System > Agent Operating Rules and System > Memory before acting. Follow links into the relevant Area until you have sufficient context.

Do not ask me to repeat information that already exists in the system. Search and verify it first.

Store durable information and deliverables in the correct Notion page or database. Do not leave important work only inside this chat or a temporary file.

Prefer updating an existing canonical page over creating another page. Link every new page from its Area or place it in the appropriate database.

Use the Task Queue as the control plane. Follow its status lifecycle and Agent Operating Protocol.

Research, draft and prepare autonomously. Stop before sending, publishing, signing, charging, deleting or otherwise taking an irreversible external action.

Record completed work in today's Daily Note and update Memory when a durable fact or preference changes.

Never invent missing personal, business, legal, financial or technical facts. Ask one precise question or mark the unresolved field.

If the Notion connector is unavailable, tell me before beginning.

END BOOTSTRAP

Also document where this instruction should be placed for each AI tool I use:

Global custom instructions
Project instructions
Repository instruction files
Agent configuration
Scheduled automation prompts

Phase 13: Optional agent sweep

If I approve scheduled processing, write a separate automation specification.

The sweep should:

Query Queued tasks.
Skip examples and tasks already owned by another process.
Order by urgency, due date and age.
Process a safe number of tasks per run.
Follow the Agent Operating Protocol.
Stop at Needs You before irreversible actions.
Record failures or missing access clearly.
Never repeatedly retry a destructive or externally visible action.
Update the task and Daily Notes after every run.

Do not activate a schedule or external automation without my explicit permission.

Phase 14: Views and usability

Make the system usable from desktop and phone.

Home should show:

Queued tasks
Active tasks
Needs You
Active projects
Recently updated resources
Today's Daily Note
Links to all Areas

Create a separate phone-friendly Control page containing:

A short explanation of how to queue work
A New Task button or obvious database entry point
The Inbox view
The Needs Me view
The lifecycle explanation

The owner should be able to capture a rough task from a phone by entering only:

Task title
Status = Queued

Area, Type, Priority and Due should remain optional at capture time because the agent can triage them.

Phase 15: Test the system

Create one clearly labeled example task:

EXAMPLE - Research and draft a one-page recommendation

Run it through a simulated lifecycle:

Queued
Triaged with Work Order
In Progress
Needs You with review checklist
Simulated approval
Done with deliverable and Daily Note links

Do not take any real external action during the test.

Verify:

Every core page is linked from Home.
Every new page has a canonical parent.
Task Queue properties and views work.
The example task contains a complete Work Order.
Needs You clearly explains the required human action.
Daily Notes link back to the task.
Memory distinguishes durable facts from activity logs.
Bootstrap contains live URLs.
No personal values were invented.
No duplicate systems were created.
No irreversible action occurred without approval.

Final handoff

When complete, provide:

A concise architecture map.
Direct links to Home, System, Memory, Task Queue, Daily Notes, Areas and Bootstrap.
Every database schema.
Every view created.
The task lifecycle.
The approval rules.
The example task result.
Any placeholders I still need to complete.
Any connector or permission gaps.
Recommended next automations, clearly separated from what is already active.

Do not describe the system as finished until the structure exists, links have been verified, the sample task works and the final handoff contains the live Notion URLs.

Filed under: notion, ai, os

Copy this prompt as markdown