Skip to content
Conductor

Case study

Conductor: an AI project manager that only marks work done when the merge proves it

Category
AI agents, project management software, developer tooling
Engagement type
Product build, packaged as a single-tenant subscription
Stack
Python, FastAPI, LangChain, LangGraph, PostgreSQL with pgvector, Next.js, TypeScript, Docker

Summary

Conductor is an agentic AI project manager for software teams. Its agents read project documents and résumés, turn them into an assigned task plan, watch GitHub, review pull requests against the team's own coding playbooks, close tasks when a deterministic rule proves the work is merged, raise risk alerts, and write grounded status emails. Every high-impact action pauses for a human decision, every autonomous action is audited, and nothing is ever declared done from a narrative alone.

OriginSphere Technologies designed and built Conductor end to end, from the agent architecture to the admin console, and now offers it as a single-tenant deployment under a monthly subscription: one isolated stack per customer, on our infrastructure or yours, with your own model provider.

The problem: project management that trusts status updates

Software delivery teams run on second-hand information. A project manager asks "is it done?", a developer answers from memory, a ticket gets dragged to the Done column, and the tracker becomes a record of what people said rather than what shipped. Reviews lag, standards drift per project, and the weekly status report is assembled by hand from Slack, GitHub and email.

The first wave of "AI for project management" made this worse. A chat assistant that summarises a board still relies on that board being true, and an LLM asked "is this task complete?" will happily say yes.

The brief for Conductor was therefore strict:

  1. Ground everything in real data. Task status must derive from commits, pull requests and review outcomes, never from an LLM's opinion.
  2. Keep humans in the loop for high-impact actions. Assignments, sensitive feedback and outbound email must pause for approval.
  3. Make the agents the product. The API and the console exist to configure, observe and override the agents, not to be another CRUD tracker.
  4. Stay provider-agnostic. Local inference today, a hosted model tomorrow, by configuration rather than a rewrite.
  5. Be sellable as a private, single-tenant system, because the inputs (résumés, emails, source code) are exactly the data a services company will not put in a shared SaaS.

The solution: narrow agents, deterministic control flow, explicit gates

Conductor's intelligence comes from how the agents are wired together, not from one large chat loop. Each agent is a node in a LangGraph graph that makes a single structured LLM call and returns data. Routing between nodes is pure Python. The "is it done?" decision is a pure function over database rows.

Three graphs, one lifecycle

Planning supervisor (admin-triggered, human-gated). Upload a BRD or FRD and the developers' résumés. The profile agent builds a skill profile per developer. The planner decomposes the documents into modules and tasks with acceptance criteria, estimates, priorities and dependencies. The task list pauses for approval. The assignment agent then proposes who does what, using the profiles, the project's developer pools and a configurable active-task capacity, and pauses again. On approval, a provisioning agent creates the GitHub repositories and webhooks. Change orders re-enter the same graph with a diff of added, modified and cancelled tasks.

Oversight pipeline (GitHub-triggered, autonomous but overridable). Every signed webhook event runs commit monitoring, code review and completion. The review agent reads the diff, the linked task's acceptance criteria and the active playbooks for the stacks touched, and records a verdict with findings. The completion step then applies one deterministic rule: a task closes only when a linked pull request is merged into the repository's default branch, the latest review covers that exact merged commit, the review did not request changes or flag a high-severity finding, and the acceptance criteria are marked met. Anything else is recorded as blocked, with the reasons, and an admin can force-complete or reopen with a stated reason that lands in the audit log.

Communication graph (event- or schedule-triggered, gated by kind). Review feedback, risk alerts and the weekly executive digest are composed by the agent from real records, then either sent or paused for approval depending on the configured policy. Inbound replies are read from the mailbox, threaded, and embedded into memory.

Memory that retrieves rather than retrains

"Train the AI on our standards and emails" is delivered as retrieval, not fine-tuning. Emails, reviews, completions and activated playbooks are embedded into PostgreSQL with pgvector and retrieved before an agent composes or judges. A Recon agent distils uploaded coding-standard documents into a structured rule set per technology stack; once an admin activates it, code review retrieves the matching playbook for every pull request and may request changes on a clear violation.

A daily risk monitor with no LLM in the loop

Overdue tasks, stale tasks, blocked tasks, developers over capacity, tasks with no activity, long-open pull requests and milestones at risk of their target date are computed deterministically every day. Only the resulting alert email is written by a model, and repeat findings are latched for a configurable cooldown so nobody is paged twice for the same problem.

A console built to observe and override

The Next.js console opens on Today: decisions waiting, grounded risks, agents currently running, and a per-project "Measure Strip" that shows each project's live status mix at a glance. From there:

  • Decisions is the human-in-the-loop queue for plans, assignments and gated emails.
  • Projects are workspaces with overview, tasks, team, risks and updates tabs.
  • Workboard shows every task as a board, grouped list, table or timeline; drag actions exist only where an audited endpoint exists.
  • People holds the roster, résumé-built skill profiles and assignment pools.
  • Playbooks manages per-stack standards from upload through distillation to activation.
  • Mail, Activity and AI usage give email threads with reply-gap triage, the full audit log, and per-agent token telemetry.
  • Settings lets an admin change the model provider, GitHub, SMTP or IMAP configuration at runtime, with inline credential verification and secrets encrypted at rest.

A first-run checklist on Today walks a new tenant from "model configured" to "first project planned" in eight checks.

Why single-tenant, and why subscription

Conductor handles résumés, private repositories, code diffs and internal email. A shared multi-tenant database is the wrong shape for that data and for the buyers who own it. Single-tenant packaging was a design constraint from the start, and it now sets the commercial model.

Each subscription gets an isolated stack: its own PostgreSQL database and encryption keys, its own API and console containers, its own GitHub app credentials and mailbox, and its own model endpoint. Nothing is pooled between customers.

Deploy anywhere Docker runs. The stack is three containers behind a reverse proxy. Local inference through LM Studio keeps every prompt inside the customer's network; switching to OpenAI is a single setting. Microsoft Entra ID single sign-on and Microsoft Graph mail are available for Microsoft 365 organisations.

What the subscription covers

  • Provisioning of the tenant stack on OriginSphere Technologies infrastructure, or a guided install on the customer's server.
  • Versioned releases pulled from a private registry, each pinned to the exact build that passed the test pipeline, with one-command rollback.
  • Configuration of the GitHub, email and model integrations, plus the first playbooks.
  • Security patches, migrations and monitoring, with support hours and an uptime commitment defined per plan.
  • No per-seat pricing pressure: plans are per tenant, sized by active projects and developers.

See our plans for what each tier covers.

Engineering facts

AreaWhat was delivered
Agents12 agent modules across 3 LangGraph graphs, a deterministic supervisor and a change-order path that reuses the planning graph
API75 endpoints across 22 routers, role-based access control on every route (admin, executive, developer)
Data17 Alembic migrations; PostgreSQL 16 with pgvector for memory; secrets encrypted at rest with Fernet
IntegrationsGitHub webhooks with HMAC verification and polling, SMTP and IMAP, Microsoft Graph mail, Microsoft Entra ID SSO, LM Studio and OpenAI through one factory
Audit77 distinct audit event types covering every autonomous action and every manual override, each with actor, timestamp and reasoning
Tests860 backend tests, 279 frontend tests and 84 website tests, run on every pull request before an image is published
CodebaseAbout 18,000 lines of typed Python and 20,500 lines of TypeScript
DeliveryPull-request-gated pipeline: test, publish to a container registry, deploy pinned by commit, serialised rollouts

Security posture

  • Backend-enforced RBAC on every endpoint; the console's guards are convenience only.
  • JWT access tokens held in memory with rotating refresh tokens, reuse detection and revocation on password change.
  • Login, refresh and SSO exchange are rate-limited; failed logins are audited.
  • GitHub webhook signatures verified in constant time; payload size capped before parsing; upload size capped for every document route.
  • Production boot refuses default or weak secrets and hides API documentation.
  • Prompts treat third-party text as data: a pull-request description that claims the acceptance criteria are met is never treated as evidence.

What we learned

  • Deterministic beats agentic wherever a rule can be written. The completion decision, the risk monitor and the graph routing are all plain functions. They are testable, explainable to a customer, and immune to prompt drift.
  • Interrupt-safe side effects need discipline. A graph node that pauses for approval re-runs from the start on resume, so every database write lives in a node that runs exactly once. This shaped the three-node "propose, await, apply" pattern used by every gate.
  • Idempotency is the integration layer's whole job. Webhooks and polls both write with upserts, reviews are keyed by pull request and commit, and inbound mail deduplicates on message id, so a replay never creates a duplicate task, review or email.
  • Telemetry is a callback, not a code change. Token usage per agent, flow and project is captured by a single LangChain callback attached where every run is configured.

Call to action

Book a walkthrough of a live Conductor tenant, or request a pilot on your own GitHub organisation.

Book a walkthrough, request a pilot, or read the frequently asked questions.

See Conductor on your own repositories

Book a walkthrough of a live tenant, or request a pilot on your GitHub organisation.