# Build Your Own Agentic OS in Notion

> A comprehensive implementation prompt for turning Notion into a shared memory layer, task control plane, approval gate and work-history system for interchangeable AI agents.

*Prompt · July 15, 2026*

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:

1. One canonical Home page.
2. A durable Memory layer.
3. Agent Operating Rules.
4. A task queue that acts as the control plane.
5. A human approval gate before irreversible actions.
6. Daily Notes that record what happened and when.
7. Area pages that organize different parts of my work.
8. Templates and SOPs for repeatable work.
9. A bootstrap instruction that connects any AI agent to the same system.
10. 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:

1. Search my Notion workspace for existing pages or databases that already serve these functions.
2. Identify duplicates, existing task systems, project databases, knowledge repositories and daily logs.
3. Preserve existing content.
4. Prefer extending or consolidating an existing canonical page over creating a duplicate.
5. Never delete, archive, rename or restructure existing content without showing me the proposed change first.
6. Do not create orphan pages.
7. 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:

1. Read System > Agent Operating Rules.
2. Read System > Memory.
3. Open the relevant Area page.
4. Follow its links until sufficient context has been gathered.
5. 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:

1. Agent Operating Rules
2. Memory
3. Personal or Business Profile
4. Agent Operating Protocol
5. Templates
6. Tool Registry
7. SOPs
8. Bootstrap for AI Tools
9. 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:

1. Open Home.
2. Read Agent Operating Rules.
3. Read Memory.
4. Open the relevant Area.
5. Inspect related projects, people, prior deliverables and recent Daily Notes.
6. Identify missing information.
7. 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:

1. Identity and profile
   - Who I am
   - Business or professional identity
   - Contact and document defaults
   - Never store passwords or secrets

2. Preferences and operating rules
   - Communication preferences
   - Writing preferences
   - Decision-making style
   - Approval boundaries
   - Recurring dislikes and constraints

3. Domain knowledge
   - Work areas
   - Products and services
   - Brand or voice guidance
   - Technical systems
   - Reusable research and assets

4. Relationship memory
   - Clients, collaborators, vendors and important contacts
   - Context and preferences
   - Link to dedicated records instead of duplicating everything here

5. Work-state memory
   - Active projects
   - Decisions
   - Open loops
   - Current priorities
   - Link to the authoritative project or task record

6. Episodic memory
   - What happened and when
   - Stored in Daily Notes
   - Important events may be promoted into durable Memory

7. 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:

1. Check whether the fact already exists.
2. Update the canonical record rather than duplicating it.
3. Record its source.
4. Link it from the correct Area.
5. Add the change to today's Daily Note.
6. 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:

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

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

3. 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.

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

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

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

7. Close
   - 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:

1. Inbox
   - Filter: Status = Queued
   - Sort: Priority descending, Due ascending, Created ascending

2. Active
   - Filter: Status is Triaged or In Progress

3. Needs Me
   - Filter: Status = Needs You
   - Show Needs From You prominently

4. Approved
   - Filter: Status = Approved

5. Board by Status
   - Group by Status

6. By Area
   - Group by Area

7. Calendar
   - Calendar using Due

8. 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:

1. Trigger
2. Required context
3. Steps
4. Deliverable
5. Storage destination
6. Approval gate
7. Completion criteria
8. Daily Note requirements
9. 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:

1. 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.

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

3. 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.

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

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

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

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

8. 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:

1. Query Queued tasks.
2. Skip examples and tasks already owned by another process.
3. Order by urgency, due date and age.
4. Process a safe number of tasks per run.
5. Follow the Agent Operating Protocol.
6. Stop at Needs You before irreversible actions.
7. Record failures or missing access clearly.
8. Never repeatedly retry a destructive or externally visible action.
9. 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:

1. Queued
2. Triaged with Work Order
3. In Progress
4. Needs You with review checklist
5. Simulated approval
6. 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:

1. A concise architecture map.
2. Direct links to Home, System, Memory, Task Queue, Daily Notes, Areas and Bootstrap.
3. Every database schema.
4. Every view created.
5. The task lifecycle.
6. The approval rules.
7. The example task result.
8. Any placeholders I still need to complete.
9. Any connector or permission gaps.
10. 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.

**Tags:** Notion, Agentic OS, Memory, Task Management, AI Agents

[Open on the site →](https://www.agenticamit.com/prompt/build-your-own-agentic-os-in-notion)