The Anatomy of an Agentic Function: Defining Machine-Executable Tasks

In today's fast-paced world, traditional project management feels broken. We spend endless hours in status meetings, manually updating Gantt charts, and chasing down dependencies. Our project management tools are little more than glorified to-do lists—passive databases that require a human operator to interpret information and drive action. They record what needs to be done, but they can't do it.

What if we could change that? What if a task wasn't just a line of text on a screen, but a living, executable 'function' that understood its own purpose?

This is the core idea behind agentic project management and the concept of an "agentic function." At projects.do, we see this as the fundamental building block for the future of work—transforming static plans into dynamic, automated workflows.

From Passive Task to Active Function

So, what exactly is an agentic function?

Simply put, an agentic function is a self-contained, machine-readable unit of work. It’s a task definition so rich with context that an AI agent can understand, automate, and execute it from start to finish.

Think about the difference between a traditional task and an agentic one:

Traditional Task: "Send marketing copy to legal for review."
- This is a memo for a human. It relies on a person to find the document, draft an email, attach the file, send it to the right person, and then remember to follow up.
Agentic Function: This defines the entire operation as code. It specifies the trigger, the inputs, the tools to use, the exact action to perform, and a clear definition of 'done'.
- This is a script for an AI agent. It is a machine-executable instruction that initiates and manages the entire review process automatically.

The Anatomy of an Agentic Function

To make a task truly executable by an AI, it needs to be defined with specific, structured components. This is the anatomy that turns a simple instruction into a powerful, automated action.

Trigger (event): What kicks off the function? An agentic function doesn't wait for a human to click "start." It listens for events.
- Examples: A dependency being met ('design.assets.approved'), a specific date being reached, or an external API call from your CRM.
Inputs (context): What raw materials does the agent need to perform the action?
- Examples: A link to a Google Doc, a customer ID, a marketing budget value, or the output from a previous function.
Action (verb & tools): The core operation. This tells the agent what to do and how to do it by specifying the systems it needs to interact with.
- Examples: send_email using the Gmail API, create_ticket in Jira, or summarize_document using a large language model.
Completion Criteria (definitionOfDone): How does the system know the function is complete and successful? This is the most critical component for enabling true automation.
- Examples: A Jira ticket status changing to 'Done', a specific keyword like 'approved' appearing in an email response, or a successful 200 OK status from an API call.
Outputs (artifacts): What does the function produce? The result of one function often becomes the input for the next.
- Examples: The ID of a newly created Jira ticket, a URL to a generated report, or a summary of a lengthy document.
Handlers (onSuccess / onFailure): Defines the next steps in the workflow, creating a resilient, branching logic that can handle exceptions without human intervention.
- Examples: On success, trigger the 'notify.stakeholders' function. On failure, execute 'escalate.to.manager'.

Bringing Agentic Functions to Life with projects.do

This "Projects-as-Code" philosophy is the engine behind projects.do. You don't just list tasks; you define them as structured, agentic functions within your project spec.

Let's look at how you'd define a task from our "Q4 Product Launch" project. Instead of just writing "Request Legal Review," you define it as an executable block:

import { Agent } from 'projects.do';

const projectAgent = new Agent();

// A task within our larger project
const legalReviewTask = await projectAgent.createTask({
  project: 'q4-product-launch',
  name: 'Request Legal Review of Marketing Copy',
  
  // TRIGGER: Starts automatically when this dependency is met
  dependencies: ['marketing.copy.draft.completed'],

  // ACTION & TOOLS: The agent knows what to do and how
  action: {
    verb: 'create_ticket',
    tool: 'jira',
    inputs: {
      assignee: 'legal.team@example.com',
      documentUrl: 'get_output("marketing.copy.draft.completed").documentUrl',
      dueDate: 'T+3d' // 3 business days from execution
    }
  },

  // COMPLETION CRITERIA: The workflow knows when to proceed
  completionCriteria: {
    field: 'jira.ticket.status',
    value: 'Approved'
  },
  
  // OUTPUT: The result is stored for the next step
  outputs: ['jira.ticket.id']
});

In this example, the AI agent doesn't need a project manager to intervene.

It knows when to start: as soon as the marketing copy draft is marked complete.
It knows what to do: create a Jira ticket.
It has the context: it pulls the document URL from the previous step's output and assigns it to the legal team.
It knows when it's done: it monitors the Jira ticket until the status is "Approved."

This is the power of true automated workflows.

The Shift from Passive Record to Active Executor

Traditional project management tools are passive systems of record. They are databases with a UI, and you are the CPU responsible for processing the information and taking action.

projects.do flips this model. We provide an active system of execution. You define the project logic as code, and our agentic platform becomes the CPU that executes it. This is the essence of Business-as-Code—transforming your strategic plans into automated, on-demand services that run themselves.

By defining your work through agentic functions, you’re not just managing a project; you are programming a valuable business outcome. You move from being a manual task-juggler to being the architect of an intelligent, automated system.