AIOS Automation Primitives

Section 01

The Automation Spectrum

Not every task should be fully automated. Before building anything, it's important to understand where a workflow sits on the spectrum — and how to move it forward intentionally.

The spectrum runs from 0% (fully manual) to 100% (fully automated). But for most business-significant tasks, Assisted and Delegated are the practical target zones.

Automation Spectrum ← Start here · Move right deliberately

0%

Manual

You do the work. No AI involved. Every task is a human task.

Where most start

80%

Assisted

You invoke an AI workflow. AI handles ~80%, you steer the result.

Invocable skill

95%

Delegated

Trigger or schedule runs the workflow automatically. You review outputs.

Triggered / scheduled

100%

Automated

Pure business logic. No AI judgment needed — it just runs.

Scripts / cron jobs

💡

The golden rule: Always start in Assisted mode. Use a workflow yourself — many times — before delegating it. You can't delegate what you haven't refined. Running something 5, 10, or 20 times in Assisted mode is what makes delegation trustworthy.

Real example: A thumbnail generation workflow (thumb gen) starts as an Assisted skill you invoke manually. After 20 runs you've dialed in the strategy, tone, and format. At that point, wiring it to a trigger (e.g., "video moves to 'Uploading' in Notion") lets it run delegated — spitting out 50 options for you to pick from.

Section 02

The Three Core Primitives

Every AIOS system — no matter how complex — is built from the same three building blocks. Think of these as the vocabulary for designing, explaining, and scaling automation.

🔌

Capabilities

Always-on · Non-invocable

Skills that give your AIOS access to APIs, tools, and external platforms. They activate automatically whenever your AI determines they're needed — you never call them directly.

⚙️

Scripts

Deterministic · Reliable

Code that does the same thing every time. No AI judgment — just consistent, reliable execution. Used for data movement, triggers, and the mechanical parts of any workflow.

🔀

Workflows

Invocable · Composed

The combination layer. A workflow ties together capabilities, scripts, and prompts into a structured AI process you (or a trigger) can invoke to accomplish a real business task.

🧩

These primitives stack. Capabilities power your AI's reach. Scripts provide the reliability backbone. Workflows combine both into something that can be invoked, refined, and eventually delegated. You can't skip primitives — rushing to build workflows without solid capabilities and scripts results in brittle, inconsistent systems.

Section 03

Capabilities — Deep Dive

A capability is a skill you give your AIOS that expands what it can do — without you having to think about it. The key characteristic: capabilities are non-invocable. They sit in the background, waiting to be triggered by context. When you mention a YouTube video, your AI reaches for the transcript capability. You never had to call it.

🔌

Capabilities

Non-invocable · Always-on · Contextually activated

Capabilities come in two flavors: General Purpose (useful across any task) and Integrations (specific to a tool in your business stack). A well-configured AIOS ships with a default stack of general purpose capabilities installed — then adds integrations based on your specific tech stack.

Set user_invocable: false in the skill file. This is what makes it a capability vs. a workflow — the AI can use it, but users can't slash-invoke it.
Always-on awareness: The skill description lives in every session context. The AI knows when to reach for it automatically, even if you never mention it explicitly.
API-connected: Capabilities teach your AI how to call external APIs — endpoints, auth patterns, and common use cases are all baked into the skill file.

General Purpose

Non-invocable

Useful for any task, any client. These are your "default stack" — install them once and they make your entire AIOS smarter across the board.

Examples: Video transcript API (SuperData), writing style guide, diagram creator, podcast transcript extractor, web research tools.

Integrations

Non-invocable

Specific to your business tools. Install the ones that match your tech stack. Plug in your API keys and your AIOS can operate each platform directly.

Examples: CRM (HubSpot, Close.io), Gmail, community platform (Circle), scheduling tools, project management.

The vision for a mature AIOS is: Context OS + default capabilities + integration capabilities = an AI that can run your entire business from a single workspace. You tell it what you need, and it knows exactly which APIs and tools to reach for without asking.

Section 04

Scripts — The Reliability Backbone

Scripts are the deterministic layer of AIOS — code that does exactly the same thing every time, with no AI judgment involved. Think of them as Zapier or Make replacements, but written as actual code in your workspace, giving you far more flexibility and control.

⚙️

Scripts

Deterministic · Consistent · No AI judgment required

Scripts are where reliability lives. When something needs to happen exactly the same way every time — move this file, log this data, trigger when X happens — that's a script. They form the structural scaffolding that makes AI workflows trustworthy.

# Example: data collect script (runs on schedule)
def collect_daily_data():
    data = fetch_from_crm()          # deterministic API call
    save_to_context_store(data)     # always saves to same location
    trigger_briefing_workflow()       # hands off to AI workflow
          

Replaces no-code tools: Scripts can handle everything a 20-50 node Zapier or Make workflow does — but they're faster, cheaper, and version-controllable in your workspace.
Trigger and schedule aware: Scripts are how you set up cron jobs and event-based triggers. When something happens in Notion, your CRM, or your calendar — a script catches it and passes it to a workflow.
Feed into workflows: The most powerful use: scripts handle the mechanical parts (data fetch, file operations, status checks) and then hand control to an AI workflow for the judgment-heavy parts.

⚡

When to use a script vs. a workflow: If there's no AI judgment needed — just reliable movement or transformation of data — write a script. Scripts are also the right tool for the 100% automated end of the spectrum: cron jobs, file watchers, and system-to-system data bridges.

Section 05

Workflows — Where It All Comes Together

Workflows are the invocable layer. They combine capabilities, scripts, and natural language prompts into a structured AI process you can call directly — with a slash command — or wire to a trigger for delegation. Workflows are what you actually use day-to-day.

🔀

Workflows

Invocable · Composed · Refinable · Delegatable

A workflow is a skill with user_invocable: true. You call it with a slash command, provide inputs, and collaborate with your AI through the process. Over time, as you refine it, you move it toward delegation — eventually wiring it to a trigger so it runs without you initiating it.

Invocable by design: Users can call /thumb-gen, /repurpose-linkedin, or any custom workflow. The skill file walks the AI through the steps.
Combine everything: A workflow can call scripts (for data), activate capabilities (for APIs), and use natural language prompting — all in sequence, in one coherent process.
Designed to be refined: Start rough. Run it 5–20 times in Assisted mode, improving each iteration. The workflow gets better as you use it — until it's ready to delegate.
Delegatable: Once a workflow is dialed in, wire it to a trigger (Notion status change, new email, cron schedule). It runs in the background and delivers outputs for your review.

Assisted Workflow

You invoke it

You run /workflow-name. AI does ~80%. You stay in the loop, reviewing and guiding. Best for new or nuanced workflows.

Example: /repurpose-linkedin with a YouTube URL — you pick the format, review drafts, approve.

Delegated Workflow

Trigger invokes it

A trigger or schedule kicks it off. AI does ~95%. You review the batch of outputs — don't run the process.

Example: Video moves to "Uploading" → 5 LinkedIn content pieces appear in a folder for your review.

Section 06

How the Primitives Stack

Capabilities, scripts, and workflows aren't used in isolation — they stack into three levels of automation. Each level builds on the previous, giving you an upgrade path from basic to powerful.

L1

Basic

Basic Automations (Scripts only)

Deterministic code automations. Scripts that run on a trigger or schedule, moving data, syncing systems, or preparing the inputs for a future AI workflow. No AI judgment needed. These replace Zapier and Make for simple, reliable operations.

Scripts Cron triggers Data sync File operations

L2

AI Workflow

AI Workflows (Capabilities + Scripts + Prompts)

You invoke the workflow, the AI does 80%, and you stay in the loop to guide output quality. Capabilities expand what the AI can access. Scripts handle the mechanical steps. Natural language prompting drives the judgment-heavy parts. This is the Assisted zone.

Capabilities Scripts Workflows Slash commands

L3

AI Automation

AI Automations (Trigger-driven, Delegated)

A refined workflow wired to a trigger. Runs in the background, produces a batch of outputs, and surfaces them for your review. You go from running the workflow to reviewing its results. This is only achievable after extensive refinement in L2 — never jump here first.

Capabilities Scripts Delegated Workflows Event triggers Batch outputs

🗺

Your upgrade path: Start every new process at L2 in Assisted mode. Use your capabilities to give the AI the access it needs. Use scripts for the parts that should never vary. Refine the workflow until you trust it — then connect it to a trigger and move to L3. Never attempt to skip L2.

Q&A

Frequently Asked Questions

Questions from the live workshop, answered.

Should background capabilities always be non-invocable? ▼

Yes — if a capability is meant to activate automatically when relevant context is detected, set user_invocable: false. This prevents users from accidentally triggering it as a workflow and keeps it as a background power-up. Only set invocable to true when you intend for users to explicitly call it with a slash command.

Which integrations should a business prioritize building first? ▼

Start with your core business platforms: CRM (GHL, HubSpot, Close), communication (Gmail, Slack), and project management (Notion, ClickUp). These are the platforms you touch every day. Once those capabilities are installed, your AIOS can operate your core business workflow without switching apps. Secondary integrations (social media APIs, analytics, billing) come next.

How do I create a capability for a new API I want to connect? ▼

There's a dedicated workflow for this. Ask your AIOS to research the API documentation and generate a capability skill file for you. The skill file should include: the API description, available endpoints, authentication pattern, and a set of common use-case examples. Set user_invocable: false and drop it in your skills folder. Your AI will automatically know how to use it next session.

How long should I run a workflow in Assisted mode before delegating it? ▼

Run it until the output quality is consistently good and you've stopped needing to correct the same mistakes. For most workflows, 5–20 runs is a reasonable baseline. High-stakes workflows (client-facing proposals, content publishing) may need more. The signal to delegate: you're no longer actively improving it during each run — you're just reviewing.

What tasks should never be fully automated? ▼

Any task with significant business judgment or client-facing stakes: proposals, pricing decisions, complex communications, creative strategy. For these, Delegated (review before publish) is the maximum level of automation. Full automation (L1 scripts) is best reserved for pure data operations, file management, and system-to-system syncs where output format is always predictable.

What's the overall promise of AIOS for a business? ▼

A contextual AI assistant that understands your business, has access to all your tools, and can automate tasks across the organization — without you having to switch between a dozen apps. The AIOS becomes the operating layer through which you run your business: a single workspace that knows your clients, your workflows, your voice, and your data.

Key Takeaways

What to Remember

Takeaway 01

Learn the vocabulary first

Capabilities, Scripts, and Workflows are the building blocks. Everything you build with AIOS is a combination of these three. Get clear on which is which before you start.

Takeaway 02

Earn delegation; don't jump to it

Assisted mode is not a starting phase to rush through. It's where you build the quality and trust that makes delegation safe. Skip it and your automated workflows will be unreliable.

Takeaway 03

Capabilities multiply everything

Every capability you add makes all your workflows more powerful — because any workflow can now reach for that capability automatically. Build your default stack early.

Takeaway 04

Scripts provide the reliability floor

AI is flexible; scripts are reliable. Use scripts for the parts that must never vary. This makes your AI workflows more consistent and easier to delegate with confidence.

Takeaway 05

Context OS is the foundation

Capabilities and workflows only reach their potential when your AIOS already has deep business context. The starter kit and Context OS come first — primitives build on top.

Takeaway 06

AIOS is a living system

An AIOS isn't configured once and forgotten. You continuously add capabilities, refine workflows, and push promising ones toward delegation as your trust in them grows.

Your Roadmap

Next Steps — Deploy Your First Primitives

Put this module into practice with these concrete actions. Complete them in order — each one prepares the ground for the next.

Audit your current tech stack and list the 3–5 platforms you touch every day. These become your first integration capabilities to build or install.

Install the default general-purpose capability stack into your AIOS workspace. Writing style guide, diagram creator, transcript API, and web research tools are good starting points.

Pick one recurring task you do manually 3+ times per week. Build an Assisted workflow for it. Don't try to automate it yet — just make it faster with a slash command first.

Run that workflow 10 times. Improve it each iteration. Track where you have to correct it. When you stop correcting the same things — it's ready to consider for delegation.

Identify one purely mechanical task (data sync, file operation, status check) and script it. This becomes your first L1 automation — reliable, always-on, no AI needed.

Complete the Task Audit module to score and prioritize your automation backlog. Use the framework to decide what to assist, delegate, or fully automate.

🚀

The AIOS promise: When your Context OS, default capabilities, and integration capabilities are all in place, your AI operating system knows your business and can reach every tool you use — from a single workspace. That's the goal. These primitives are how you get there.

Continue Learning

Related Modules

These modules connect directly to what you just learned.