The control plane for agentic engineering

Agents do the work. Direct decides how far it goes.

AI agents can already investigate an issue, write the change and open the pull request. What they can't do is tell you whether they should have. Direct is the governed system around them: journeys, gates, evidence, and a line of sight from production back to the backlog.

Coming soon · it runs our own engineering today
app.cratis.direct/global
The Direct Today page: a headline counting the things that need a person, tiles for agents working, failing builds and what shipped overnight, and the items that need you.

Real screenshot from production. Today, the front door. Direct doesn't open on everything; it opens on what only a person can resolve, and says that everything else is moving.

The problem

Speed was never the hard part.

Once agents can write code, the constraint moves. It becomes deciding what they work on, proving what they did, and noticing when the world changed underneath them.

An agent that starts on everything spends tokens on everything.

A label flips to "agent can do this" and work begins. Nobody chose it, nobody capped it, and the bill is the first signal.

With Direct: nothing starts until a person admits it into a journey with a work ceiling. Classification describes an issue; it never starts one.

A merged pull request is not evidence.

"The tests passed" and "the model said it was fine" don't answer why a change was allowed to ship, or under whose rules.

With Direct: every stage ends at a gate that evaluates recorded evidence against versioned rules. The verdict, the evidence and the rule version are kept.

Production talks in a channel nobody has time to read.

The alert fires every five minutes, a human reads it eventually, and an agent could have fixed it in thirty seconds.

With Direct: the alert lands where an agent investigates it at once. If it can't resolve it, a person gets the findings, not a notification.
What Direct is

Five rungs. Climb as far as you trust them.

Most tools automate one loop: the one that writes code. Engineering is more than that. Direct covers the whole cycle from intent to production and back, and each rung lets agents take on more of the work. Every rung has the same guardrails: a person decides, the rules are visible, the history is kept.

Rung 1

Deliver

issues → released code

Backlog, stories, journeys, pull requests and failed builds. Issues move from intake through investigation, plan, implementation and release, behind gates, up to a ceiling you set.

Rung 2

Observe

products · environments · signals

Products, the environments they run in and the resources they use, with Prometheus, Loki, Tempo and HTTP signals bound to each.

Rung 3

Monitor

probes · alerts · incidents

Probes and webhooks raise alerts. Incidents keep a history and publish reviewed status updates.

Rung 4

Heal

investigate · remediate

An agent investigates every alert and remediates through the operations gate, within the action policies you set per environment.

Rung 5

Fix

diagnose → journey → verified

A diagnosis becomes a governed issue. It is fixed, released and verified by the same probe that raised the alert.

Assure runs through every rung: each stage ends at a gate. Around the ladder sit Publish (content and outlets), Steer (vision, roadmap, deliveries) and Learn (suggestions from what people do). We call the whole thing agentic operations.

The front door

Finding what needs you. Everything else is moving.

Direct is built for a few people supervising many agents, so it doesn't greet you with everything. It greets you with what only a person can resolve: an agent's question, a gate waiting for review, an alert it couldn't fix, an issue from outside the team.

app.cratis.direct/product/inbox
The Direct Inbox: a list of items assigned to you, agent questions and mentions on the left, and the selected item with a reply box, Mark done, Open journey and Send reply on the right.

The Inbox. Assigned work, agent questions and mentions in one list. Reply in place, mark it done, or open the journey it belongs to.

One queue for the things that need a person.

The signal is the point. Completed work stops being clutter, and nothing interrupts you for what an agent can settle alone.

  • Reach you where you are. Browser push on each device you choose, email, and Slack or Microsoft Teams as a direct message with buttons to act on it. Installed as an app, the icon carries the inbox count.
  • Settled once, settled everywhere. Answer in Direct, approve in Slack, or let the alert close: every copy of the notification then says so, and a phone stops asking.
  • Agents ask, and wait. A worker that needs a decision stops and asks. The question lands here with the journey it belongs to.
  • Community in view. Open issues from outside the team that nobody on the team has answered yet, newest first.
Rung 1 · Deliver — the journey

Work starts in exactly one way.

A journey is the life of one issue or blog post, recorded as events on its own stream. It moves through stages. Between every pair of stages sits a gate. Only a gate that allows can move it on.

01 / stageIntake
G01
02 / stageInvestigation
G02
03 / stagePlan
G03
04 / stageImplementation
G04
05 / stageRelease
G05
outcomeComplete
Issue journey · 5 gates · nothing on any screen can set a stage directly — every action is a command the journey decides on

Admit, then set a ceiling.

You pick issues from the backlog and choose how far work may proceed: pause after investigation, after the plan, after implementation, or run through to release. The ceiling is where work stops. Every stage up to it still has to pass its gate.

  • Preview before you commit. Direct splits your selection into ready and held, with a reason for each held item.
  • One journey per subject. An issue already in a journey can't be admitted twice.
  • Extend scope later. Raise the ceiling from the board when the gate has earned it.
  • Replies steer the next stage. A comment on the agent's write-up becomes input for the next dispatch instead of starting a second run.
  • Changed intent is judged, not ignored. If the title or body changes after the plan, the Decision Engine says whether the plan still holds. If it can't tell, you decide.
app.cratis.direct/product/journeys?journey=…
A journey held at its Intake gate: the stage rail, a What is needed from you panel explaining why it stopped and the options, and the gate's evidence broken down by outcome.

Held, and told why. Two remediation attempts didn't resolve the finding, so Direct stopped sending the stage back to the agent. It says what happened, what the options are, and which rules came back with which outcome.

app.cratis.direct/product/journeys
The Direct Journeys board: every issue as a card in Intake, Investigation, Plan, Implementation or Release, with the things that need a person called out, and a banner offering a suggestion Direct learned.

The Journeys board. Every issue as a card in its stage. Cards that need a person are flagged, cards blocked by reality say so, and a banner appears when Direct has learned something about how these journeys run.

app.cratis.direct/product/stories/…
A story in Direct: description, canvas, event model, design, investigation and issues tabs, with a conversation panel where Muse answers when mentioned.

A story. The description on the left feeds an event model and a design. The conversation on the right is where people, and Muse, shape it.

Shape it before it is work.

Not everything starts as a clean issue. A story is where a capability gets shaped with people and Muse until it is ready for its journey: description, canvas, event model, design and investigation.

  • Talk it through. Invite people in. Muse answers when mentioned, or on every message if you prefer.
  • Generate from the description. Update the event model, or generate a design, from what is written.
  • Marking it ready writes the issues. The agent attaches the designs you picked to the issues they belong to, then the story starts its journey.

Reviewed where the work is.

Every pull request across the tracked repositories is mirrored and kept current by webhooks. Read the change, the checks and the merge decisions without leaving Direct.

  • Completed work finds its issues. A pull request is associated with the issues it covers and marks them for review.
  • Accepting merges it. A person accepts the pull request in Direct and it merges through the GitHub API.
  • Move to journey. A pull request that arrived on its own can be brought into a journey and its gates.
app.cratis.direct/product/pull-requests
The Pull requests page: a filterable list of open pull requests and the selected pull request with Overview, Merge decisions and Resource usage tabs and the diff.

Pull requests. The list on the left, the selected change on the right, with the diff, merge decisions and what the work cost.

Reality check

Journeys stay honest against what actually happened.

Every 15 minutes, and whenever a journey changes, Direct compares the journey's record with the facts of the work. A mismatch becomes drift and stops the journey advancing: subject closed, a pull request merged before Release, a worker that failed without finishing, a publication taken down, or governance that changed under it.

Five journey types

One engine for issues, stories, deliveries, posts and fixes.

The issue journey runs Intake → Investigation → Plan → Implementation → Release. Stories, deliveries, blog posts and operations actions each have their own stages and gates. Same engine, same board, same designer.

Assure — gates on every rung

A gate decides. Evidence and rules explain why.

A gate collects every rule bound to it, evaluates each against the recorded evidence, maps each finding to an outcome, and takes the most restrictive one. Your organization writes the rules. You can read, simulate and version them.

Five outcomes, ordered by how much they ask of you.

AllowThe work may proceed.
Requires human reviewA person approves, with a reason, for exactly the evidence evaluated.
Requires explanationSomeone explains. The explanation becomes evidence for a new attempt.
Requires remediationThe stage is worked again. After two attempts a person decides.
BlockFix the cause first. A block can't be bypassed by asking for a redo.

Unknown is never a pass. Missing evidence, an evaluator error, low confidence or a result that hasn't arrived all default to human review. A late result for evidence that has since changed is recorded but can never authorize the current work.

app.cratis.direct/product/adlc-designer
The ADLC / Journey Designer showing gate G04, Implementation quality, with a rule palette on the left, the gate policy in the middle and its settings on the right.

The ADLC / Journey Designer. Gate G04, Implementation quality, with 16 required rules, a palette of 37 reusable rules and the validate, simulate, review, approve, activate path along the top. Deterministic checks, Roslyn analysis and LLM judgement sit in one policy.

RuleEvaluatorWhen it doesn't pass
G01 · Intake
Security screeningDeterministicHuman review
Spam and solicitationLLMBlock
ActionableLLMRemediation
G03 · Plan quality
Unplanned scopeLLMExplanation
Breaking changes plannedLLMHuman review
Security controlsDecision EngineBlock
G04 · Implementation quality
Build and tests passDeterministicRemediation
Static analysisRoslynRemediation
Tests not weakenedLLMBlock
Security scanExternal toolBlock
Review policyCompositeHuman review
G05 · Release
MergedDeterministicBlock

Excerpt of our own active governance — 37 rule bindings across the 5 gates of the issue journey, read from the Designer.

Six kinds of evaluator. Pick the cheapest one that can decide.

A rule names one evaluator. Cheap deterministic checks run first in spirit; a language model is asked only where judgement is the point.

Deterministic fields & thresholds Composite all / any / threshold / sequence LLM structured finding + confidence Decision Engine configured choices External tool or job Roslyn build diagnostics
  • A low-confidence verdict counts as Unknown. Only a recognized, explained verdict at or above the configured confidence concludes anything.
  • Tool rules wait. A rule handed to an external scanner stays pending until the result arrives for the evidence evaluated.
  • Not applicable isn't passed. A required gate with no applicable rule holds as a configuration problem.
  • Dismissals are evidence. Dismiss a screening flag as a false positive and the rule passes on re-evaluation, with your decision on file. Screen again and it still blocks? The dismissal stops counting.

Governance is versioned, and only a person activates it.

Draft→ Validate→ Simulate→ Review→ Approve→ Active v2
Journeys keep their version

Activating never rewrites work in flight.

A journey keeps the governance it was admitted under. When a newer version changes a gate it still has to pass, Direct raises drift and lets you adopt it deliberately.

Validate + simulate

Break it on a whiteboard, not in a release.

Validation rejects unreachable stages, rule cycles, bindings with no evidence source and outcome maps that let "unknown" allow. Simulation runs a gate against real or typed-in evidence and never calls a model.

Scopes + provenance

Override in one area without changing everywhere.

Product and Content can override a rule's parameters. Each value shows whether it is inherited, overridden, local or excluded, so you always know where a setting came from.

app.cratis.direct/product/adlc-designer
The Simulate dialog in the Journey Designer: choose a gate, simulate against an example situation or a real issue, toggle which evidence exists, and run.

Simulate. Pick a gate, then an example situation or a real issue, and switch evidence on and off. It reports which rules apply and what the gate would conclude. Nothing real changes.

Try a gate before it decides anything.

The version selector shows the whole history: the active version, drafts and the initial governance Direct shipped. Rule packs have versions too, and a newer pack arrives as a draft you can read, validate and simulate. It never changes what is running.

  • Five journey types, one designer. Blog post, Issue, Story, Delivery and Operations action each show their own stages and gates.
  • Canvas or list. See the gates as a flow, or every rule bound to every gate as a table.
  • Governance packs and evidence export are available as modules: starter rule sets to adopt and adapt, and gate decisions with their evidence for reviewers.
Classification & intake

Classification describes. Admission decides.

Every issue is classified and screened the moment it is registered. The results are recorded as facts with their provenance. None of them starts work, and none of them blocks you from starting it.

KindBug, task or feature. Changed on the issue itself.
FeasibilityWhether an agent can plausibly do it, or it needs a person.
CriticalityHow much it matters. Feeds priority, not permission.
SemVer impactThe release the change warrants. Shown as a guess, with the question mark.
Model tierWhich capability tier should implement it. Cheap work isn't sent to the expensive model.
LabelsApplied from a known set, weighed by the Decision Engine.
ScreeningSecurity (text written to steer an agent) and content (spam, solicitation, conduct), on every issue and every comment.

A person can always say otherwise.

These are bounded questions with a known set of answers, so Direct doesn't ask an open-ended agent. It asks a decision engine and records the verdict.

  • Your classification sits beside the classifier's. It's recorded as an attributed decision. It doesn't overwrite the machine's verdict.
  • Readiness is separate. Ready, Pending or Held — held only when the issue is closed, screening blocked it, or its body says too little.
  • Unclassified issues can still start. Direct won't make you wait for a label to spend your own budget.
  • Outsiders don't trigger work. An issue from outside the organization is screened, flagged and kept away from agents until you decide.
  • Flagged text is shown as plain text. It's content marked as hostile, so it is never rendered.
app.cratis.direct/product/issues
The Issues page: every issue ordered by priority with labels, readiness and a Start Journey button on each row, and a Deliveries panel on the right collecting related issues.

Issues. Every issue from GitHub, from Direct or from a story, ordered by priority. Drag to reorder; drop one onto another to start a delivery. Readiness sits beside each row and Start Journey is the only way work begins. Deliveries collect on the right.

Learn · preview

Direct watches what people do. Then it suggests.

Governance written once goes stale. Direct watches how work actually moves, tunes small things by itself with an Undo on each, and for anything that changes how work is governed it only suggests. A person decides.

Evidence for changing a rule, not a hunch.

A gate that asked for a review 78 times, and was approved 78 times with no problem getting through, becomes a suggestion with its evidence: let this gate pass without a review.

  • Suggestions come with the why. What Direct saw, what would change, and the choices: propose it for review, not now, or never suggest it again.
  • Loosening needs a second person. A suggestion that would loosen a gate asks for a second reviewer before anything applies.
  • Four things it learns from. Delivery matching, journey patterns, gate outcomes and agent plans.
  • Tuned by itself, undone by you. Small adjustments are listed with why, when and an Undo.
app.cratis.direct/product/learning
The Learning page: tabs for Overview, Delivery matching, Journey patterns, Gate outcomes and Agent plans, summary tiles, and a suggestion to let the plan-quality gate pass without a review with the evidence behind it.

Learning. A real suggestion from our own production: the plan-quality gate, seen 78 times with nothing against it, with the evidence and a button to propose the change for review.

Rungs 2–5 · Observe, Monitor, Heal, Fix

From an alert to a verified fix, before anyone opens a laptop.

A watchdog that finds something wrong has two options: wake someone or be ignored. Direct adds a third. The alert goes to an agent that looks at once and resolves what it can. For a bug, the diagnosis becomes a governed issue, and the probe that raised the alert confirms the fix landed. Whatever is left reaches a person with the evidence.

01 · live

Signal

A resource probe, a failed build or a webhook from your systems. Direct reads its own payload and the Discord webhook shape.

02 · live

Deduplicate

One alert per fingerprint. A resource down six hours costs one alert and one investigation.

03 · live

Investigate

A worker with only the operational access you granted: a cluster, a runtime, logs.

04 · live

Resolve or hand over

Resolved by the agent, or Needs attention with findings attached.

05 · live

Fix through a journey

The diagnosis becomes an issue that enters a governed journey, gates included.

06 · live

Verify in production

The same resource probe confirms the fix landed, and the alert closes itself.

Healing goes through a gate too.

An agent that can restart a pod can also restart the wrong one. Remediation is an operations gate, and what it may do is a policy per action and environment kind, not a prompt.

  • Review means an agent proposes and a person approves before it runs.
  • Never means it cannot run, however confident the agent is. Changing data or schema is the example.
  • Every action leaves a record. Recent actions and every action are listed with who asked and what happened.
  • Incidents are public when you say so. Reviewed updates publish to a status page, Statuspage, Cachet, openstatus or a webhook.
ActionPolicy in production
Restart podReview
Scale outReview
Roll back releaseReview
Replay Chronicle partitionReview
Change data or schemaNever

Action policies. Our production environment's policies, as shown on the Operations page.

Environments and the things in them.

An operational resource is anything worth knowing the health of: a Kubernetes cluster, a namespace, a database, a Chronicle server. Resources are grouped into environments — production, staging, a customer's installation — and nest, so a namespace is probed through its cluster's credentials.

  • A resource type is a class. Add a technology by writing a class. There's no registry and no list to keep in step, and the Add dialog builds its form from what the type says it needs.
  • Readings are documents. Transitions are events. A probe every minute is 1,440 rows a day that would drown the log. Healthy → unhealthy is a fact and lives forever.
  • Unknown is never reported. A resource added a moment ago hasn't been looked at yet. That isn't an alert.
  • Access is granted, not assumed. With no operational access configured, an agent can only reason from the alert. The product tells you so at the top of the page.
# any system can report — this is the whole integration
POST https://<direct>/webhooks/alerts
{
  "source":      "production",
  "title":       "Loki is crash looping",
  "summary":     "loki-0: CrashLoopBackOff (restarts: 370)",
  "severity":    "critical",
  "fingerprint": "pod:loki-0:CrashLoopBackOff"
}
Operations · active investigations
01
Worker never left the starting stateScheduler · critical · investigating
02
Chronicle server cannot be reachedWatchdog · critical · findings attached
03
Reconciliation sweep has stopped runningWatchdog · needs attention · convert to issue

Illustration of the Operations board layout; rows are simplified.

Watching the watcher

The failures worth a check announce nothing.

A recurring sweep that silently stops looks exactly like "nothing to do". Direct's own watchdog checks for that shape of fault: symptoms that are an absence.

Bring your alerting

Point the webhook you already have.

If your watchdog posts to Discord, pointing it at Direct is the whole integration. No second alerting path to keep working.

Findings, not notifications

A person starts from evidence.

Annotate an alert, resolve it, or turn it into a tracked issue in one step. Browser push covers only what nothing else resolves.

Publish — content for every outlet

What shipped is only half the story.

Releases pile up faster than anyone writes about them. Direct treats a blog post like an issue: it has a brief, a draft, an editorial gate and a publication that gets verified. The weekly digest is assembled from what your repositories actually released.

app.cratis.direct/content/digest
The weekly digest: a list of editions, the selected edition's generated description with extracted themes, and an Approve and publish panel.

The weekly digest. A description generated from the week's releases, the themes it extracted, and an Approve and publish step that shows exactly what goes to which outlets. Every edition waits for a person.

A journey for words, with gates.

01Brief
02Draft
03Editorial
04Publish
  • Brief readiness. A post needs a title and an objective before an agent drafts anything.
  • Draft quality and editorial approval. Same gate machinery as code, with its own rules and its own scope in the designer.
  • Publication verification. Publishing isn't finished until the publication is observed. A taken-down post raises drift.
  • A writer agent, in a worker. Drafts come from the content repository or from the issue that motivated them.
In product

Weekly digest

Collected from releases, analysed for themes, reviewed, published.

In product

Blog

Brief to verified publication with editorial gates.

In product

Content plan & LinkedIn

A weekly plan aligned with the roadmap and what shipped. Every post records its brief, voice revision and model, and discloses AI assistance where the channel requires it.

In product · early

Talks & engagement

Talk material, and conversations worth joining with a suggested reply grounded in the product's public pages. A person decides.

Steer — products, vision, roadmap, order

Agents follow direction. Somebody has to set it.

A backlog of two thousand issues has no strategy. Direct keeps the vision next to the work, so triage and planning are grounded in what you're trying to build.

Vision

Written down, and used.

Associate repositories with a vision. Triage and planning read it, and a vision guard checks changes against it.

Roadmap

Plans generated from the issues you select.

Pick issues, get a plan. Revise it, apply it, or throw it away. The plan is a proposal and it stays one until you apply it.

Chains

Step two waits for proof that step one landed.

A fix goes into a framework; the app that consumes it can only be verified once the package is on the registry. Chains hold the later step until the release exists. The agent is told what it's continuing.

Priority

Drag to rank. Drop to group.

A group is scheduled only when every issue in it is ready. Extra instructions travel with the agent's prompt.

Capacity

Least-burnt account first.

Work draws from a pool of AI accounts within a concurrency bound, and usage is tracked per provider and model.

Steering

Watch a worker. Talk back to it.

A running job streams its console into Direct. Send text into the session to steer it, or read the retained console after it ends.

app.cratis.direct/product/products
The Products page: each registered product as a card with its repositories, journeys and what needs you, a Register a product card, and a banner about repositories that belong to no product.

Products. Each product with its repositories, journeys and what needs you. Repositories that belong to no product are called out, because their issues can't reach a digest, a vision check or an alert route.

A product is the unit everything else hangs on.

A product ties together its repositories, environments, vision, public pages and team. Every module works through it, so a release, an alert or a post always knows whose it is.

  • Failures find their owner. A failed partition or an alert is traced back to a product and filed where its code lives.
  • Deliveries cross repositories. Issues from any repository that ship together are matched to new issues automatically, and can be worked in order with gates.
  • Work can span repositories. An issue names the others it has to be worked across; every agent gets them and is told what it may do in each.
Connect

Reach it from your editor. Run workers on your own machine.

Direct is not only a website. The people and agents who work with it do so from wherever they already are.

MCP + REST

Your editor's agent can use Direct.

Member tools file plain repository issues with likely-duplicate choices, comment and label them, and ask what is waiting on you (direct_my_work, or GET /v1/me/work). Personal access tokens carry scopes such as direct:read and direct:work, every write needs an idempotency key, and each call is recorded with the verified member, the client and the protocol.

Direct Agent Runner

When the cluster isn't the right place.

Run agent workers on your own machine, in your own Docker, when they need more CPU or memory, a fast local disk or a network you control. A maintainer approves the runner with a short code. For each piece of work Direct picks the runner open to whoever asked and with the most room, and the cluster when none has more. The runner only ever dials out.

Modules

Add what your organization needs.

Product is included. Everything else is a module: install it, try it, or join a preview. Its pages and settings appear the moment it is active. This is the catalogue as it stands in the product today.

IncludedAvailablePreviewComing

Organization & product

OrganizationIncluded

People, teams and invitations, agents, AI providers and pools, decision engines, integrations, governance and notifications.

Products, vision & roadmapIncluded

Products with repositories, environments, public pages and a vision. Roadmap and decisions per product.

DeliverIncluded

Backlog, stories, journeys, work, pull requests, failed builds, inbox and dashboards.

AssureIncluded

Gates, rules, six evaluator kinds, the Journey Designer and reality checks.

GitHub providerIncluded

A mirror of organizations, repositories, issues, pull requests, checks and builds.

GitLabComing

Issues, merge requests and pipelines through the same provider adapters.

Azure DevOpsComing

Work items, pull requests and builds through the same provider adapters.

JiraComing

Issues from Jira, worked through the same journeys and gates.

Operate

Infrastructure & SignalsAvailable

Products, environments and resources. Prometheus, Loki, Tempo and HTTP signals.

Production MonitoringAvailable

Probes, alerts and incidents with public status updates.

Auto-healAvailable

An agent investigates every alert and remediates through the operations gate.

Autonomous bug fixingAvailable

A diagnosis becomes a governed issue, is fixed, released, and verified by the probe.

Govern

Governance packsAvailable

Starter rule sets to adopt and adapt.

Evidence exportAvailable

Gate decisions and evidence for reviewers and auditors.

Learning loopPreview

Recurring failures and overrides propose rule changes.

Content, marketing & sales

Content StudioAvailable

The blog journey from Brief to Publish, with voices and guidance.

MarketingAvailable

A content plan, LinkedIn publishing and a posting plan.

OnboardingAvailable

Get the organizations of a product you run for customers in the door: invitations, sign-ups, trials, seats, approvals and the emails around them.

SalesPreview

Who is evaluating, what they asked for, and where each conversation stands.

Platform

WorkflowsPreview

Schedules, reusable actions with receipts, and chains.

Agents anywhereAvailable

Direct as claim authority for agents running elsewhere over MCP.

Under the hood

Tools are not authority.

Direct is not an agent loop with a dashboard bolted on. The trusted application owns state, sequencing, credentials and capacity. The agent is a replaceable, non-root worker holding only what one unit of work needs.

Signals in

Your systems

  • GitHub issues, PRs, builds
  • Webhooks + daily reconciliation
  • Alerts from running systems
  • Resource probes
→
Trusted control plane

Direct

  • Journeys, gates, governance
  • Classification & screening
  • Queue, accounts, limits
  • Event-sourced on Chronicle
→
Bounded workers

Isolated agents

  • Docker or Kubernetes, non-root
  • Own worktree per job
  • Scoped callback token
  • Result back as comment, branch, PR
Credentials

Never in the container spec.

Provider keys, GitHub tokens and operational credentials arrive as a read-only secret file the entrypoint sources and deletes. They don't appear in kubectl get job -o yaml or docker inspect.

Source of truth

GitHub is an integration.

Direct records its own facts first and a reactor translates them into GitHub calls. A failed API call is something to recover, not a reason to lose the fact. Another provider means another adapter.

Your models

Bring your own provider.

Anthropic, OpenAI, Azure OpenAI or any OpenAI-compatible endpoint. Pool several accounts. Each agent runs on one provider or draws from a pool, and never both.

Where Direct sits

Delivery tools ship. Governance tools record. Direct does both, and goes back for production.

Autonomous-delivery products turn a backlog into pull requests. Governance products keep evidence for auditors. Direct's position is that those are the same system: the gate that lets an agent proceed is the evidence a reviewer reads later.

Autonomous delivery toolsGovernance & evidence platformsDirect
Starting pointBacklog to pull requestPipeline events to audit trailIntent to journey, up to a ceiling you set
How work is allowedLabels, approval gates, PR reviewControls checked after the factGates evaluate rules against evidence before the next stage
UncertaintyAgent escalates when unsureCompliance statusUnknown is never a pass, by construction
ProductionRarely in scopeRuntime monitoring for driftAlerts trigger agent investigations with scoped access, remediation through a gate, and a fix verified by the probe
Beyond code——Content journeys, digest, roadmap, chains
Rules live inRepo configPolicy engineVersioned governance: draft, simulate, review, activate

A category comparison, not a benchmark. We describe what each type of product sets out to do. We haven't tested competitors head to head.

Roadmap

Where it is, and where it's going.

Direct runs our own engineering today. The columns follow the module catalogue: what is available, what you can try, and what is on the way. "Coming" is direction, not a commitment, and dates move.

Now

available, running in production
  • Journeys and gates for issues, stories, deliveries, blog posts and operations actions
  • Journey Designer with versioned governance, validation and simulation
  • Today, inbox and notifications by push, email, Slack and Microsoft Teams
  • The ladder to Fix: signals, alerts, auto-heal and autonomous bug fixing
  • Content Studio, weekly digest, Marketing and LinkedIn publishing
  • Onboarding for the customers of a managed product
  • Workers on Docker, Kubernetes or your own machine, and MCP and REST access
  • Agents anywhere: Direct as claim authority for agents running elsewhere over MCP

Next

available or in preview
  • Governance packs (available): starter rule sets you can adopt and adapt
  • Evidence export (available) for reviewers and auditors
  • Learning loop (preview): recurring failures and overrides propose rule changes
  • Workflows (preview): schedules, reusable actions with receipts, and chains
  • Sales (preview): who is evaluating, and where each conversation stands
  • Wider watchdog coverage as the internal checks are re-enabled

Later

coming
  • More content outlets from one brief: newsletter, release notes, docs and more social channels
Honest limits

Where Direct stops.

Agents are only as good as the rules you activate.

A gate that has no applicable rule holds. A weak rule set passes weak work, and Direct will show you the verdict either way.

LLM rules are judgement, not proof.

They carry a confidence threshold and never turn an unclear answer into a pass. Where you need proof, bind a deterministic or tool rule.

Production access is opt-in.

Without an operational grant, an alert investigation can only reason from the alert. Some internal watchdog checks are currently paused while we harden them.

Some modules are previews.

Learning loop, Sales and Workflows are in preview, and the git and issue providers beyond GitHub are still coming. The module catalogue marks every one, and the Roadmap follows it.

It's coming soon.

Direct runs our own work today. Access opens to others in stages, so the login below will only admit accounts we've enabled.

Coming soon

Give agents a brief, a ceiling and a gate.

Already have access? Sign in with GitHub and open your journeys.