Major

Governed AI Agents Project Management: Permissions Guide

How to run governed AI agents for project management: set permissions without slowing delivery, and build a weekly controlling agent on Major with Jira and Slack.

Jose GironUpdated
Project lead mapping a quarterly roadmap on a kanban board with the team

Governed AI agents for project management are agents whose permissions, data and actions are controlled by the system they run in rather than by instructions in a prompt. To give an agent the right permissions without slowing delivery, grant read plus draft access by default, require a named approver for anything that changes scope, dates or staffing, and let the platform enforce those limits and log every action. Major is built for this: the agent works out the workflow once, builds a deterministic app for the repeatable part, and runs that app under scoped credentials, role-based access and an audit log.

This guide is for PMO leads, delivery managers and platform teams who want agents doing coordination work, with project control staying where it belongs.

How do you give AI agents the right permissions without slowing development?

Split access into three levels and grant the lowest one that works.

  • Read: retrieve approved project records and fields from Jira, Linear or Asana.
  • Draft: write proposed updates into an app the agent owns, never into the system of record.
  • Write: change specific approved fields, with a named approver and a logged decision.

Most project workflows live at read plus draft. Speed comes from making the safe path the default, so a project manager can launch a new agent without a bespoke security review each time. The control has to sit outside the model. A prompt that says "never change deadlines" is a request. A read-only Jira credential is a fact.

On Major, scoped credentials, role-based access and audit logging apply at the point where the agent acts. The tenth agent inherits the same controls as the first, so adding agents does not add review queues.

What does AI agent project controlling look like in practice?

Project controlling means tracking plan against actual and acting on variance. Agents help with the tracking and flagging, and people keep the decisions. Four jobs fit well.

  • Variance detection: compare this week's task states, estimates and due dates against the last approved baseline and list what moved.
  • Dependency monitoring: flag a prerequisite that looks unresolved before dependent work starts, naming the tasks involved.
  • Status drafting: write the weekly summary from stored facts, with blockers cited to source records.
  • Follow-up tracking: prepare a reminder tied to an approved blocker and record whether the owner replied.

Each has a defined input, a bounded output and a human gate. The agent gathers and organizes. People own scope, staffing, deadlines and anything sent outside the team. A flagged risk is evidence for a conversation. It is not a forecast, and no agent catches every risk.

What should the agent decide, and what should code decide?

Most of a weekly controlling report involves no judgment. Pull the approved fields, compare them with the baseline, apply the thresholds the team agreed, store the result. That is a program, and it should behave identically every Monday.

Judgment is the smaller slice. A comment reading "waiting on legal, probably slips" implies a delay without stating a date. Whether that counts as a blocker is a call for the model, as is writing a paragraph a stakeholder will read.

Agents that re-reason the whole report on every run pay model cost for work that never needed it, and their output drifts week to week. Put retrieval, comparison and history in an app. Keep the model for interpretation and exceptions. That is the idea behind reason once, run forever.

Build the governed weekly controlling agent on Major

Start with a read-only weekly status draft. It is easy to verify against source records and it earns trust before anyone grants write access.

  1. Connectors: Jira for tasks, comments and dependencies, and Slack for delivery. Each is configured once at the org level. The agent calls them through the credential proxy and never holds raw tokens.
  2. The app: a "Delivery Controls" app on Major's managed database. Tables hold weekly snapshots, the approved baseline, applied thresholds, open flags, drafts and review decisions. A review queue view shows the project manager each draft beside its source records.
  3. The agent's judgment: it reads the comments thresholds cannot classify, decides whether each implies a blocker, and drafts the narrative. The first time, it builds the retrieval and comparison logic into the app. Later runs call that logic.
  4. The trigger: a workflow runs Monday at 8am. Snapshot, diff and flag run as app code. The agent is invoked only for flagged items and the draft.
  5. The approval gate: the draft posts to a private Slack channel for the project manager. Nothing reaches stakeholders until a person approves.
  6. Governance: the Jira credential is read-only. The agent can create drafts in the app but cannot touch deadlines, staffing or scope. RBAC controls who sees the review queue, and every read, draft and approval lands in the audit log.

Build this agent on Major

Because state lives in the app and not in a conversation, next week's run knows what it flagged and whether the owner responded. Other agents can reuse the same app, so a program office can run the identical workflow across portfolios. For the Jira side of the plumbing, see how a GitHub to Jira triage workflow is wired, and for the Slack side, the governed Slack escalation workflow.

Which actions should always need human approval?

Anything that commits the team or reaches outside it.

  • Changes to scope, deadlines or staffing.
  • Stakeholder commitments and external status reports.
  • Escalations that name a person.
  • Any write to the system of record outside pre-approved fields.

When data is missing or conflicting, the agent stops that action and routes it to a named owner. Approval gates cost minutes when the draft arrives with its evidence attached, which is why the review queue shows source records next to the proposal.

How does this work with the tools your team already uses?

The pattern does not depend on one tracker. Teams on Linear can follow the governed Linear issue-triage app, and teams on Asana can adapt the Asana routing and reporting agent. The agent layer changes little. The app layer, the scoped credentials and the audit trail stay the same.

At portfolio level it is the same shape at larger scale. Rolling up status across dozens of projects is repeatable aggregation, which belongs in an app, with the agent reading narrative updates and flagging the few projects that need a human conversation. For buyers comparing options at that level, the guide to AI agents for PPM covers the evaluation questions.

How to roll it out

  1. Pick one project and one recurring question, such as what changed since the last update.
  2. Agree sources, fields, cadence and thresholds with the project owner.
  3. Give the agent read and draft access only.
  4. Store source references, the prior report, open flags and review decisions in the app.
  5. Have the project manager compare each draft with the records and correct errors.
  6. Expand access only after failure cases are understood and someone owns exceptions.

Once one team runs cleanly, the enterprise rollout playbook for AI agents covers extending it across teams without creating shadow systems.

Why the deterministic app layer matters for project controlling

Project history is only useful if it is the same history every time you ask. When recurring compilation runs as code, a steering committee can ask in March why a task was flagged in January and get the stored threshold, source record and approver. That is the practical difference between an agent that reasons through each report and one that built the software and then ran it. Cost follows the same shape: front-loaded when the agent builds the app, then flat as cycles repeat.

The model still does real work here. It interprets ambiguous comments and writes the narrative. It just does not redo the arithmetic, the diffing or the bookkeeping on every run.

More use cases by tool: More Asana use cases, More Jira use cases, More Slack use cases.

Start building on Major

Build a governed weekly controlling agent on Major with Jira and Slack, keep the history in an app your auditors can read, and leave every commitment with your project managers.

Related articles

Frequently asked questions

What are governed AI agents for project management?
Governed AI agents for project management read project records, draft updates and flag risks under permissions the platform enforces. Credentials are scoped, access is role-based, every action is logged, and a named person approves changes to scope, deadlines or staffing.
How can a project manager ensure AI agents have the correct permissions without slowing down development?
Default every agent to read plus draft access, so it can retrieve records and propose updates but not change the system of record. Require a named approver for writes, and enforce limits through scoped credentials and role-based access rather than prompts. Launching a new agent then needs no custom review.
What is AI agent project controlling?
It is using agents to track plan against actual: detecting variance from a baseline, monitoring dependencies, drafting status reports and following up on blockers. The agent gathers and flags evidence, and people decide on scope, deadlines and staffing.
Can an AI agent update project plans?
It can prepare proposed task, owner or status updates, but write access should be limited to approved fields. A person should confirm changes to deadlines, scope or staffing before they become project facts, and each approved change should land in an audit log.
What should a project management agent not do?
It should not commit a team to deadlines, change scope or staffing, escalate people, or send sensitive reports externally without approval. When data is missing or conflicting, the affected action should stop and go to a named human owner.