Connect the tools that already move your work.

Repair a production import without losing the review trail

• Fix a narrow regression

  Give the agent failing fixtures, a bounded file area, and an explicit test contract.

• Upgrade a dependency

  Keep the version change, compatibility proof, pull request, and review on one task.

• Implement a migration

  Require a dry run, rollback note, and named approval before the consequential step.

Tighten an audit export and return a reviewable patch

• Add contract coverage

  Ask for a small fixture-backed change and keep its proof with the pull request.

• Refactor a stable interface

  Name the behavior that cannot move, then review the patch against that boundary.

• Prepare a review batch

  Let Codex produce the patch while Aestus keeps review and merge as separate steps.

Repair a review receipt with a governed Pi session

• Repair a bounded contract

  Give Pi one failing fixture, a stable interface, and the exact focused check to run.

• Use a native approval pause

  Hold a supported consequential tool call until the named person approves or rejects it.

• Return useful memory

  Let the session propose a cited lesson without promoting it before a person reviews it.

Use Cursor locally while the team keeps one truthful task record

• Continue a team task in the editor

  Load the same requirements and artifacts the rest of the team sees on the board.

• Record a local handoff

  Attach the branch and review notes without claiming that local tokens were metered by Aestus.

• Run a hosted follow-up

  Start a separate Aestus coding run when the work needs a metered, policy-bound execution record.

Deliver a governed change through a repository-scoped GitHub App

• Open a coding-agent pull request

  Use the installed app to create the branch, commit, and bot-authored pull request.

• Keep checks with acceptance

  Return check state to the requesting card before a reviewer makes the final decision.

• Limit repository reach

  Let an administrator choose the repositories instead of distributing broad personal tokens.

Hold a customer export for one mapped approver

• Approve a customer export

  Hold delivery and ask one mapped privacy owner for one short-lived decision.

• Release a production change

  Send a bounded release prompt while the deployment state stays in Aestus.

• Reject an external write

  Return the reason to the held workflow without turning a chat thread into the system of record.

Let an agent work a Linear issue without leaving Linear

• Give triage a worker

  Map the triage state to a ready column and let an agent take the small, well-specified issues.

• Keep one team two-way

  Run a single Linear team two-way while the rest of the workspace stays import only.

• Report to the team that planned it

  Send the outcome back as a status change and a comment, where the people who filed it already look.

Deliver a Jira story while Jira stays the system of record

• Try one project first

  Import a single Jira project, check the mapping against a dry run, and turn on outbound writes after.

• Keep reporting intact

  Leave sprints, story points, and epics in Jira so the dashboards the business reads keep working.

• Return proof, not a status guess

  Send the pull request and the executed transition back to the issue the request came from.

Run the same task lifecycle from any compatible MCP client

• Connect another coding client

  Give it the same read, claim, progress, artifact, handoff, and release contract.

• Connect an internal agent

  Use OAuth or a scoped personal token while Aestus checks each task operation.

• Start hosted execution

  Create a metered run only when Aestus launches and owns the workflow execution.