Orkestra AI

Languages: English · Português (BR) · Español

From ticket to merge without living in six tabs.

A VS Code, Cursor, Antigravity, Windsurf, and Kiro extension that connects Jira, GitHub Issues, Azure DevOps, ClickUp, and Monday to your GitHub, Bitbucket Cloud, or GitLab repo, and runs a delivery pipeline with clear steps—refine, assisted implementation, PR, AI review, and fixes—all from the editor.

Website: orkestraai.com.br · Marketplace: Install · Source: github.com/djalexdee/orkestra-ai

What it is (one line)

Orkestra is not “another autocomplete.” It orchestrates the flow between task card, code, and PR—so you stop copying context between Jira, the IDE, and GitHub all day.

• Sidebar board: Kanban for tasks from the active provider.
• Numbered workflow: Refine → Start → Implement → PR → Review → Fix → Finish (with shortcuts).
• Remote PRs: comments, AI analysis, auto-fix with a configurable threshold (GitHub / Bitbucket / GitLab merge requests).

The “aha” moment (real flow)

Picture a vague Jira ticket (“improve checkout performance”).

┌─────────────────────────────────────────────────────────────────┐
│  [Orkestra AI]  Board                    ORK-184  ▼  In Progress │
├─────────────────────────────────────────────────────────────────┤
│  You pick the task on the board                                   │
│       ↓                                                           │
│  ① Refine Task  →  AI + repo scanner  →  criteria + risks         │
│       ↓                                                           │
│  ② Start Task   →  “In Progress” + repo snapshot                  │
│       ↓                                                           │
│  ③ Implement    →  task-grounded prompt in the editor             │
│       ↓                                                           │
│  ④ Create PR    →  open/draft PR on GitHub, Bitbucket, or GitLab  │
│       ↓                                                           │
│  ⑤ Review       →  sync comment thread + AI analysis on the PR    │
│       ↓                                                           │
│  ⑥ Auto Fix     →  mechanical fixes + batch commit (optional)     │
│       ↓                                                           │
│  ⑦ Finish       →  close the loop on the provider                 │
└─────────────────────────────────────────────────────────────────┘

You don’t replace human code review on large changes—but you cut friction between bad tickets, branches, PRs, and repetitive PR comments.

The problem (no fluff)

Orkestra tackles this where you already work: the editor.

The solution

Full workflow (the pipeline)

Real order in code—practical steps:

Default shortcuts (when the editor has focus — when: editorTextFocus). Command IDs are the orkestra.* ones registered in package.json (legacy devTask.* aliases still resolve to the same handlers):

Start task only (board + branch, no implement step) is orkestra.startTask—there is no default keybinding; use the Command Palette.

Command Palette (Ctrl+Shift+P): Orkestra AI category—including orkestra.reviewAdvanced, orkestra.refreshBoard, orkestra.syncRepoWithBoard, orkestra.implementationContinue, orkestra.quickStart, orkestra.linkWorkspace, orkestra.cloudSignIn, orkestra.openBillingUpgrade, etc.

The workspace (6 tabs)

The board webview lives in the Activity Bar (devTaskSidebar) and is organized into six tabs, with Settings as a gear icon in the toolbar. Each tab groups related capabilities behind a segmented sub-navigation, so you reach everything without a sprawling rail.

Main features

AI workflow

• Quickstart pipeline (refine + start + implement) and Full / Full with checkpoints (UI confirmations).
• AI orchestrator with intents (refine_task, implement_task, analyze_pr, fix_pr_comment, …) and a provider chain (LM API, chat, fallback).
• Usage gate: plan + quotas before calling a model (see Billing).

PR automation

• Open-PR detection on the branch; full analysis (POST /api/pr/:id/analyze) and zero-friction flow (threshold, batch commit, markdown summary on the PR).
• Resolve comment; PR activity in the repo.

Project intelligence

• Task suggestions from project-DNA analysis, grouped as Melhoria / Correção / Nova implementação, convertible into board tasks in one click (Insights → Risco & IA; "Reanalisar Projeto" to regenerate).
• Risk ranking + AI recommendations per task, and predictive rework analysis (batch processor) surfacing correlated risk alerts.
• Feedback loop stats on suggestion acceptance.

Goals & automation

• Goal Engine: turn a high-level objective into a set of tasks with AI, then track progress on the Goals tab.
• Agents: multi-agent control center and an autonomy engine (L5 autopilot is opt-in via orkestra.enableL5Autopilot).
• Governance: define security policies and audit autonomous decisions / violations.
• MCP ecosystem: capability federation across configured MCP servers.

Context & memory

• Project memory (local file + search / reindex); injection into refine, implement, and fixes.
• Ask Orkestra: semantic Q&A over the project (architecture, where things live), with answers that link straight to files in the editor.
• Per-task timeline and AI summary (where enabled).
• Insights (/api/insights/overview, project, Git) and a cross-workspace aggregate for cloud-synced profiles.

Integrations

• Tasks: Jira (basic + OAuth), GitHub Issues, Azure DevOps, ClickUp (personal API token or OAuth; OAuth redirect http://localhost:4567/callback), and Monday (API token or OAuth).
• Git / PR: GitHub, Bitbucket Cloud, and GitLab merge requests (orkestra.github.*, orkestra.bitbucket.*, orkestra.gitlab.token, optional orkestra.gitlab.instanceHost for self-managed).
• Figma: link a design to a task and pull design context (REST integration + MCP provider).

Developer experience

• Guided onboarding: on first install with no providers, a full-page guided flow walks you through connecting a Board provider before the rest of the workspace unlocks (SCM is optional and can be added later).
• Link / Change / Unlink Workspace for a consistent provider profile per folder.
• UI language for extension + board webview: orkestra.uiLanguage — auto (follow VS Code locale), pt-br, or en.
• Optional PR → board sync: when orkestra.sync.enable is true, the extension polls the SCM for recently merged PRs and can move linked tasks toward Done (uses persisted PR↔task links from Create PR when available).
• Embedded HTTP API (default port 19850) for automation.
• Output channels for debugging (Workflow, Review, Memory, …).

Straight comparison

Copilot and Cursor shine where you type code. Orkestra helps where work is a full delivery with task + branch + PR.

Plans

Orkestra ships several tiers — Free, Pro, Ultra, Ultra Duo, Team, and Enterprise — that gate workflow automation, PR auto-fix, advanced memory, the embedded API, and monthly quotas (tasks, workflow runs, PR analyses, AI actions). Higher tiers raise or remove limits and add team features (shared memory, custom rules, seats).

Current pricing and the exact per-tier limits live in the Conta & Plano tab inside the extension and on the website; they can change between releases, so the in-app plan comparison is the source of truth.

Upgrade from Conta & Plano or via Orkestra AI: Upgrade plan / billing (orkestra.openBillingUpgrade).

Installation

VS Code, Cursor, or Windsurf

1. Ctrl+Shift+X (or Cmd+Shift+X on Mac) → search Orkestra AI.
2. Marketplace ID: DjAlexDee.orkestra-ai
3. Install and reload the window if prompted.

Or: Extensions → … → Install from VSIX… if you have a .vsix.

Requirements: VS Code ≥ 1.80.0 (or a compatible Cursor build), folder workspace with Git (origin on github.com, bitbucket.org, or GitLab—gitlab.com by default, or a self-managed host matching orkestra.gitlab.instanceHost).

Supported platforms

PR automation supports origin on GitHub, Bitbucket, or GitLab. On GitLab.com (or *.gitlab.com remotes), set orkestra.gitlab.token (PAT with api scope), or GITLAB_TOKEN, or store a token on the board profile when linking the repo. For self-managed GitLab, set orkestra.gitlab.instanceHost to the same hostname as in git remote (e.g. gitlab.acme.com). Task providers (Jira, Azure DevOps, ClickUp, Monday, GitHub Issues) work independently of the Git host.

Quick start

1. Install from the Marketplace.
2. Open a folder with your Git clone.
3. Click Orkestra AI in the activity bar. On a fresh install with no providers, a guided onboarding opens to connect a Board provider; once connected, the Board opens.
4. Connect at least one provider (via the onboarding wizard, Settings → Profiles, or orkestra.* settings):
   • orkestra.provider: jira | github | azure | clickup | monday
   • Tokens / domain / list per provider docs.
5. Set GitHub, Bitbucket, and/or GitLab for PRs (orkestra.github.*, orkestra.bitbucket.*, orkestra.gitlab.token [+ orkestra.gitlab.instanceHost if not gitlab.com]).
6. Run Orkestra AI: Link Workspace if prompted to bind folder ↔ profile.
7. Pick a task on the board → Orkestra AI: Refine task, then Orkestra AI: Start and implement (AI) / Orkestra AI: Implement with AI, or Orkestra AI: Run full workflow (Ctrl+Shift+6).

Settings namespace (orkestra.*)

All contributed settings use the orkestra prefix (for example orkestra.provider, orkestra.jira.domain, orkestra.workflow.autoCommitBeforeCreatePr). If you upgraded from a release that used devTaskAssistant.*, the extension copies your saved overrides into orkestra.* on first activation when the new key does not already have a value, so existing installs keep working.

Concept: AI orchestration

“Orchestration” here is literal: a state machine + prompts + integrations, not one giant prompt.

• Workflow events feed memory extraction and timeline.
• Pipelines (refine, review, auto-fix) in stages: gather → build prompt → call model → apply safe output.
• Billing and quotas tied to steps and intents so you don’t blow the plan blindly.

Mental model: task-side CI/CD—inside the IDE.

Architecture (lightweight)

┌──────────────────┐     ┌─────────────────┐     ┌──────────────────┐
│  VS Code /       │     │  Embedded API   │     │  Task providers  │
│  Cursor Host     │────▶│  localhost:19850│     │  Jira / GH / ADO │
│  (extension.js)  │     │  + WebSocket    │     │  / ClickUp       │
│  React webview   │     └────────┬────────┘     └──────────────────┘
│  (6-tab rail)    │              │
└────────┬─────────┘              ▼
         │              ┌─────────────────┐
         ▼              │  Billing        │
┌──────────────────┐    │  Asaas / cloud  │
│  AI Orchestrator │    └─────────────────┘
│  + gates / usage │
└────────┬─────────┘
         │
         ├──▶ Intelligence (risk · suggestions · predictive · memory)
         ├──▶ Agents + Governance (autonomy · policies)
         ├──▶ MCP federation (capability registry)
         └──▶ SCM: GitHub / Bitbucket / GitLab MR  ·  Figma

Extension Architecture (v1.5.x)

State Management

• PlanManager: Reactive singleton for user plans, cached in globalState.
• WebviewStateManager with StateDiffEngine: Differential patches via IPC.
• PipelineCheckpointManager: Disk-based persistence of pipeline progress.

Listeners and Disposables

• Session listeners are managed by _currentWebviewSessionDisposables.
• Mandatory cleanup is triggered at the beginning of each resolveWebviewViewAction.
• Session listeners must never be directly added to context.subscriptions.

External Calls

• GitLab & Bitbucket: Routed via scmGet with a configured cacheTtlMs.
• TTL values are declared in src/git/scm-cache-config.ts.
• Invalidation is handled by webhook handlers in boardViewProviderCore.ts.

Git Operations

• All Git operations in normal flow are run asynchronously via runGitAsync / tryRunGitAsync.
• Synchronous calls (runGitSync) are deprecated and only used in extension activation/deactivation.
• Standard 15-second timeout applies to each Git command.

Rollback and Recovery

• Hard reset is never automatic; it always requires manual confirmation ({ modal: true }).
• Checkpoints are saved after each pipeline stage under .vscode-ork/pipeline-checkpoints/.
• Automatic resume option is offered next time the extension opens.

Security & billing (honest summary)

• Plans and quotas on the host: Free vs Pro changes flags (automation, auto-fix, memory, API) and numeric limits.
• Local API: JWT / API key in production; Asaas webhook requires a token when enabled; WebSocket requires credentials.
• Cloud: orkestra.cloudBillingBaseUrl / ORKESTRA_CLOUD_BILLING_URL + JWT via Orkestra AI: Sign in (cloud billing) (orkestra.cloudSignIn); optional orkestra.cloudAuthBrowserFlow for browser OAuth when the backend supports it; optional analytics events. Orkestra AI: Configure CPF/CNPJ (checkout) (orkestra.configureBillingCpf) when your billing flow requires it.

Details can change by release—see src/saas/ and src/api/.

Roadmap

• GitLab merge requests (GitLab.com + self-managed): shipped (orkestra.gitlab.*). Deeper extras (labels, approvals, …) as the API surface grows.
• Other SCM (e.g. Azure Repos) for the same PR flow where feasible—track issues for status.
• Multi-device sync of core state via backend (less local JSON reliance).
• Richer analytics + offline queues.
• Enterprise: seats, SSO, policies—sales conversation.

Small, focused PRs (one integration or one workflow step) are easier to merge than huge diffs.

Development (from source)

git clone https://github.com/djalexdee/orkestra-ai.git
cd orkestra-ai
npm install
npm run compile

In VS Code: F5 → Extension Development Host.

The Nest cloud billing API is built and deployed from a separate repository (not this extension tree). Set orkestra.cloudBillingBaseUrl (or ORKESTRA_CLOUD_BILLING_URL) and use Orkestra AI: Sign in (cloud billing) for the JWT. HTTP contract, Asaas webhooks, and ops: docs/SAAS_BILLING_ARCHITECTURE.md.

Contributing

1. Open an Issue with the problem or idea (or comment on an existing one).
2. Fork → short-lived branch → PR describing changes and how to test.
3. Prefer small PRs (one theme: bugfix, one provider, one workflow step).

License

MIT — see LICENSE.md.

Links

Note on the marketing site

The site summarizes the product for visitors; this repo is the source of truth. If something diverges (e.g. roadmap integrations), the repository wins. Website copy suggestions are welcome via issues.