Stop Figuring Out What to Delegate to AI

Filipp Mishchenko — Fri, 05 Jun 2026 12:46:22 +0000

I built an open-source task queue that separates human work, AI-ready work, blocked work, and review-ready output.

The Problem

Most AI tools still assume the human knows exactly what to ask.

That sounds reasonable until you use coding agents, inbox automation, Slack
summaries, meeting notes, and personal task capture every day. The bottleneck is
not always execution. Often, the bottleneck is deciding what should be delegated
to AI in the first place.

I kept running into the same operational question:

Which of these tasks should I do, and which ones can an AI agent take from here?

That question is surprisingly expensive.

It requires reading context, identifying the next action, checking whether a
credential or decision is missing, deciding whether the result needs review, and
only then assigning the work to a person or an agent.

So I built Personal Task Assistant.

The core idea is simple:

Stop figuring out what to delegate to AI. Let the task system surface AI-ready work.

What It Is

Personal Task Assistant is an open-source interface for collaboration between a
person and an AI agent.

It turns work into an operational queue with clear ownership:

tasks for the human;
tasks an AI agent can execute;
tasks waiting for human review;
blocked tasks;
unassigned tasks that still need triage.

It is not trying to replace Jira, Linear, Asana, YouTrack, Trello, Slack,
Telegram, or email.

Instead, it exposes a small task model and JSON API so user-owned adapters can
bring tasks in from those systems.

Why This Needs a Different Model

A normal task tracker answers:

What needs to be done?

An AI-assisted workflow needs another question:

Who should do the next step?

That second question changes the product shape.

A task can be technically simple but blocked by a missing decision. Another task
can be complex but fully agent-ready. A third task may already be finished by an
agent but should not be marked done until a human reviews the output.

That is why Personal Task Assistant tracks both status and next-action owner.

Statuses:

backlog
in_progress
waiting_review
blocked
done
cancelled

Owners:

me
codex
unassigned

The value is not the labels themselves. The value is the filtered queue:

What do I need to do?
What can the agent do?
What is ready for review?
What is blocked?
What is overdue?

The Agent Queue

The important endpoint is:

curl "$TASK_TRACKER_URL/api/agent/queue?assignee=codex&sort=smart&limit=25" \
  -H "Authorization: Bearer $TASK_TRACKER_API_KEY"

Example response:

{
  "summary": {
    "active": 42,
    "overdue": 3,
    "due_soon": 4,
    "codex_ready": 12,
    "human_input": 18,
    "review": 5,
    "blocked": 2,
    "unassigned": 1
  },
  "tasks": []
}

This means an agent does not need to scrape the UI or read every task. It can
ask for an execution queue.

Ingesting Work From Context

Agents or adapters can send extracted tasks through the context-ingest endpoint:

curl -X POST "$TASK_TRACKER_URL/api/agent/ingest/context" \
  -H "Authorization: Bearer $TASK_TRACKER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "origin": "email",
    "source_name": "Gmail thread from Alice",
    "source_url": "https://mail.google.com/...",
    "source_context": "Alice asked for revised numbers by Friday.",
    "tasks": [
      {
        "title": "Send Alice revised numbers",
        "assignee": "me",
        "priority": 2,
        "reminder_at": "2026-05-07T09:00:00Z"
      }
    ]
  }'

The same pattern works for Slack, Telegram, Linear, Jira, Asana, YouTrack,
Trello, meeting notes, or any other source.

The project intentionally does not ship with built-in credentials or universal
source clients. The safer pattern is to keep adapters small and owned by the
user.

Local Setup

The fastest setup path is:

git clone https://github.com/J3d1-fm/Personal-Task-Assistant
cd Personal-Task-Assistant
python3 scripts/setup_wizard.py

Manual setup:

python3 -m venv .venv
. .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env
uvicorn app.main:app --reload

Then open:

http://127.0.0.1:8000

The local setup uses SQLite. The intended hosted shape is Cloud Run plus
Firestore, with secrets stored outside the repository.

Architecture

The current MVP is deliberately small:

FastAPI serves the web UI and JSON API.
SQLite stores tasks locally.
Firestore is supported for Google Cloud deployments.
Google OAuth can protect the browser UI.
Bearer-token auth protects API clients.
Reminder polling can query /api/reminders/due.
Agent clients can read /api/agent/queue.

The data model stays compact:

title and description;
status;
assignee;
origin;
priority;
due date;
reminder date;
source name, source URL, and source context.

If a task does not include a due date, the server estimates one from priority:

P1: about 1 day;
P2: about 3 days;
P3: about 7 days;
P4: about 14 days;
P5: about 30 days.

It is not meant to replace real deadlines. It is meant to prevent important
captured tasks from silently aging without a date.

What I Want Feedback On

The most useful feedback right now:

Is the human/agent ownership model clear?
Is waiting_review the right default state for completed agent work?
What should the first real adapters be: Slack, Telegram, Gmail, Linear, Jira, Asana, YouTrack, or Trello?
Should the agent queue expose more ranking information?
What would make the local setup easier?

Why I Think This Layer Matters

AI agents are getting better at execution.

But execution is only one part of the workflow. The harder daily problem is
routing work correctly:

delegate this;
do this yourself;
review this;
unblock this;
ignore this.

That is why I think the next useful layer around agents is not another chat
window. It is a delegation layer.

Personal Task Assistant is my first open-source attempt at that layer.

Repository:
https://github.com/J3d1-fm/Personal-Task-Assistant

DEV Community: Filipp Mishchenko