[TOK-01] What is Task Ontology Kernel (TOK)?

When "task" is no longer just a mental concept for humans, but becomes a native Primitive of the system.

Starting from an Observation

Have you noticed that when you repeatedly use LLMs, you naturally start doing something — organizing, saving, and reusing your Prompts?

At first, a Prompt is just a piece of text. It disappears once you're done.

But when you discover a Prompt that works particularly well, you start to:

• Save it
• Give it a name
• Add a version number
• Try to reuse it in different scenarios

At that moment, the Prompt is no longer just a Prompt.

It has become a Task.

Tasks Have Always Existed, But Were Never "Formalized"

Think about it: "Analyze API performance for me," "Build a login module," "Refactor this code" — these are all tasks. But before LLMs came along, they could only exist in human minds, or scattered across Todo Lists, Slack messages, and meeting notes.

They were unstructured mental concepts.

Nobody thought this was a problem, because in the past, only humans could "execute" tasks. Humans can accept vague instructions and automatically fill in missing context.

But LLMs changed everything.

LLMs Are the First "General-Purpose Task Executor" in Human History

Before LLMs, there were only two kinds of "executors": humans, or specialized software.

Now, LLMs can execute almost any cognitive task: analysis, writing, planning, transformation, design, debugging. No need to write specific code for each task.

This means that for the first time, tasks can be directly read and executed by machines.

But the prerequisite is — tasks must become structured.

This Is How TOK Was Born

Task Ontology Kernel solves exactly this problem. It defines:

1. What is a task? — The structure, identity, and properties of a task
2. How does a task exist? — State, lifecycle, and dependencies
3. How does a task evolve? — Versioning, feedback, and strategy iteration

TOK is not a tool, not a system, nor a framework. It is a theoretical foundation — just like Lambda Calculus is to programming languages, or the Relational Model is to databases.

TOK is to Task-native systems what the Relational Model is to relational databases.

What Does a Task Look Like?

In TOK, each task is composed of four layers:

Intent Layer

Describes "what to achieve," not "how to do it."

Context Layer

The environment, permissions, and historical records needed for execution.

Strategy Layer

Task decomposition logic and tool preferences. Can evolve with experience, not a hard-coded process.

Evaluation Layer

The verification protocol for task success — the Definition of Done.

Here's a concrete example:

{
  "id": "task-001",
  "intent": "Analyze API performance logs and generate a summary report",
  "context": {
    "domain": "backend",
    "resources": ["DB read access"]
  },
  "strategy": {
    "steps": ["Aggregate logs", "Calculate percentile metrics", "Generate summary"],
    "tools": ["Python script", "LLM"]
  },
  "evaluation": {
    "definitionOfDone": "Summary aligns with log metrics",
    "tests": ["unit test", "semantic alignment check"]
  }
}

This is no longer a vague text description. It is a structured object that can be directly parsed, executed, and validated by AI.

Why "Ontology"?

The word "Ontology" sounds academic, but its core meaning is very intuitive: defining what "things" exist in a system and how they relate to each other.

Every successful system has its core Primitive:

System	Primitive	Essence
Unix / Linux	Process	Process Ontology Kernel
Git	Commit	Version Ontology Kernel
Kubernetes	Pod	Container Ontology Kernel
TOK	Task	Task Ontology Kernel

Unix didn't "invent" the concept of files. But Unix was the first to make "file" a native Primitive of the system.

TOK doesn't invent "tasks" either. It is the first to formalize tasks as a system Primitive that can be natively executed by AI.

What Does This Mean?

This represents a fundamental paradigm shift in software engineering:

Code-native era: Human intent → Translated into code → Computer executes
Task-native era: Human intent → Structured as tasks → Agent executes

Code hasn't disappeared — it has shifted from being the "core asset" to a "derived tool." Just like when you use Git, the "commit" is the core unit, and files are just attachments to commits.

In Task-native systems, the task becomes the smallest native unit of execution, governance, and evolution, while code becomes a derived artifact generated or coordinated by tasks.

Conclusion: Not Reinventing Tasks, But Formalizing Them for the First Time

Great abstraction discoveries always make you feel "wasn't it always this way?" File, Object, Function, Container — none of them were new things; they were simply formalized for the first time.

TOK is the same.

Tasks have always existed. But after LLMs emerged, tasks finally have the chance to become executable system units — and TOK is the ontological structure defined for this very moment.

👉 Next: What is TOCA? The Core Loop of Task-Oriented Cognitive Architecture

---

Full content: https://enjtorian.github.io/task-ontology-kernel/