Site rebuilt around the new category
Repositioned from founder productivity to decision execution infrastructure. New ICP: ops and eng leads, 20–150 people, Linear + Slack.
Pre-launch · MVP live
A decision, made once. Done everywhere it needs to happen.
Conductor turns a directive — a Slack message, a voice note, a one-line decision — into owned, typed work executing directly in Linear, Slack, Notion, and Gmail. No copy-paste. No “did anyone actually do this.”
The gap
Your tools all stop at the same place.
Notion stores knowledge. Jira stores work. Slack distributes messages. None of them turn a decision into accountable action.
Knowledge tools
Notion and its peers hold what the company knows. A decision written down there sits still until someone manually turns it into work somewhere else.
Work trackers
Jira and Linear track work objects once they exist. They don't decide what the objects should be, who owns them, or why they were created.
Messaging tools
Slack is where decisions actually get made — and where they go to die. The thread scrolls away; the follow-through depends on memory.
The fix isn't a smarter place to write things down. It's removing the manual translation step entirely.
Decision execution infrastructure is the layer between a decision being made and the work it causes being tracked, owned, and done. That layer is what Conductor is.
Why now
Two things changed in the last twelve months.
01
Structured output got reliable
Until roughly a year ago, you couldn't trust a model to turn messy human intent into structured, typed output consistently enough to act on it. That threshold has been crossed. A directive can now become a dependable data structure, not a hopeful paragraph.
02
Agents need a governed execution plane
As AI agents multiply, organizations need a layer with guardrails and audit trails between intent and action. Conductor is MCP-native from day one, built to be the plane other agents call through — that's a positioning bet, stated as a bet.
How it works
Say it once. It's already moving.
-
Say the decision once
A Slack message, a voice note, a one-liner. Conductor sanitizes the input, triages it, and decomposes it into a typed execution graph — owned, dependency-ordered actions, not a summary.
-
Watch it get typed and routed
Each action lands in a lane: Decide (needs your judgment), Delegate (goes to an owner, in their tool), or Defer (parked with a revisit date). Guardrails check every action against policy before anything moves.
-
Approve, and it's already done
On approval, the Linear ticket exists, the Slack message is sent, the Notion page is written. Decision memory records the rationale, so the next similar decision routes faster.
See it work
Three directives, decomposed.
Representative walkthroughs of the live product loop. The cards, tickets, and messages below are what Conductor actually produces in Linear, Slack, Notion, and Gmail.
“We're cutting the Q3 paid budget by 40% — tell marketing why, get finance to send the final spend number, and draft the replacement plan for review.”
directive · via Slack · budget review
Delegate
Message to #marketing explaining the cut and the reasoning behind it.
Delegate
Request to finance for the final Q3 spend number, due before the plan review.
Decide
Replacement plan drafted and flagged for the requester's review, with a deadline.
“Kill the Spring Launch campaign. Tell the agency, open a ticket to pause the ad sets, and get a post-mortem on the calendar by Friday.”
directive · via Slack · kill campaign
Delegate
Email to the agency announcing the stop, drafted for approval — external sends always need a human.
Delegate
Ticket to pause all Spring Launch ad sets, assigned to the growth owner.
Decide
Post-mortem scope proposed: attendees, agenda, Friday slot. One approval schedules it.
“We need SOC 2 Type II kicked off — find out who owns vendor reviews, open the evidence tracker, and hold the policy rewrites until the auditor confirms scope.”
directive · via Slack · SOC 2 prep
Delegate
Ticket asking the engineering lead to confirm vendor-review ownership.
Delegate
Evidence tracker created from the SOC 2 template, linked back to the directive.
Defer
Policy rewrites parked until auditor scope is confirmed. Revisits automatically.
What makes it different
Conductor executes. It doesn't draft.
Three mechanisms, not adjectives.
Typed execution graph
Every directive becomes a dependency-ordered graph of typed actions with owners and systems of record. Not a paragraph of suggestions — a structure that can be executed, checked, and audited.
Guardrails, not blind execution
Every action passes a policy check before it touches a tool. Internal tickets can auto-execute after approval; external messages always wait for a human. Escalation rules are set per workspace.
Decision memory
Every approved or rejected card teaches the system this team's judgment — who owns what, what gets escalated, what “urgent” means here. It compounds with use and doesn't transfer if you switch tools.
$0.0004
Average model cost per directive processed
<50ms
Decision-memory retrieval (pgvector + HNSW)
15+
Hours per week teams lose to decision translation
Modeled, not measuredBuild log
Shipped recently.
Morning Briefing shipped
A 90-second Slack summary of what happened, what's still open, and why the original decision was made. The memory loop, not just the execution loop.
Notion and Gmail execution live
Four tools now executed natively: Linear, Slack, Notion, Gmail.
The founder
Built by one engineer who has been the translation layer.
Conductor is designed and built by Burhan, founder of Min15x — currently a solo engineer, with one engineering hire planned as the first use of funds.
The guardrail stage sits in front of execution by deliberate choice: a system that acts in your name has to be boring before it can be clever. That one decision shaped the whole pipeline — sanitize, triage, synthesize, guardrail, execute, learn — and it's why Conductor can be trusted with real actions instead of drafts.
Pre-launch. MVP live. Raising a small round to prove the loop.
The fastest way to diligence this is a direct conversation. No forms, no funnel.