Directionally installs better instincts into AI agents.
Directionally turns repeated agent corrections into behavior packs that fire before the same mistake repeats.
When it changes what your agent does, you get a receipt: what it was about to do, what it did instead, and the proof. Software has packages for code reuse; agents need packages for judgment reuse.
AI agents do not inherit the corrections your team already paid for.
Right now, you’re the one catching it. Your agent is capable — but you keep re-explaining the same things: look before editing, prove the fix, match the repo’s conventions. The lessons just die where they happen.
- A correction appears in a PR comment — and dies in that thread.
- A warning is sent in Slack — and doesn’t reach the next session.
- A rule is added to a local file — and doesn’t travel to the next tool.
- A senior engineer catches something — and it stays in their head.
The next agent run does not inherit it. So the same correction gets paid for again. Every repeated mistake is lost organizational learning turned into operational drag.
This is a familiar infrastructure pattern showing up in a new place. Experienced engineering teams already know how to turn repeated operational mistakes into durable systems: runbooks, CI checks, linters, deployment gates, review norms, platform defaults, and internal tooling. Agents broke that loop. The correction now happens inside a chat, PR comment, terminal trace, or one-off human override — and disappears before the next agent run.
Skills teach an agent what it can do. Rules state preferences. Memory recalls context. None of them turn corrections into portable, runtime-active behavior.
The agent was about to delete the wrong files.
Cleanup task. Glob expands across the repo. Agent prepares to delete matched files.
Data Destruction Needs A Noun — a glob match is not a target list.
Lists matched files by name, states intended scope, requires confirmation before touching anything outside it.
Proposed delete → listed files → confirmation required → accepted by user. 14 seconds added. Deletion outside scope avoided.
Directionally does not block the agent. It changes the next action before the mistake compounds.
Scattered corrections should become behavior packs, not more comments.
Directionally is for the moments where your agent has the ability, but needs an injection of taste.
Directionally applies developer-platform thinking to agent behavior. Teams already turn repeated infrastructure failures into checks, defaults, and workflows. Directionally turns repeated agent corrections into behavior packs that fire at runtime.
The correction compiler aggregates PR comments, trace notes, human overrides, and rejected agent actions — finds the shared failure pattern — and compiles it into a pack that redirects agents before the pattern repeats.
The library is live today: hundreds of named instincts across eight behavior packs — coding safety, git and PR sanity, debugging evidence, deploy and runtime reality, data safety, spec, and migration. Private packs compiled from a team’s own corrections, and shared team packs across developers and repos, are the next motion.
Debugging Evidence
You haven’t seen the bug until you’ve reproduced it.
Catches your agent debugging from vibes — before it has a repro, logs, or the real failure.
Deploy / Runtime Reality
Passing locally isn’t the same as working where it runs.
Catches your agent calling a deploy done without checking config, runtime, or release reality.
Git / PR Sanity
Know your git state before you touch the branch.
Catches your agent making a mess of diffs, branches, generated files, or the PR handoff.
Users do not buy receipts. They buy agents with better judgment. Receipts are how Directionally learns which instincts work.
Agents moved from chat to action.
Generation is abundant. Senior judgment is scarce. Entelligence found that only $0.18 of every AI coding-tool dollar becomes shipped product; the rest is consumed by reactive engineering, code rework, and review friction.
Every repeated agent mistake is a small piece of that $0.82 recurring. A behavior pack that catches the repeat pays for itself on the first useful catch — and compounds across future sessions.
Bad responses used to mean annoyance. Now they mean bad commits, unsafe deletions, broken deployments, and wasted review cycles. More autonomy creates more corrections. More corrections create the raw material for behavior packs.
Claude Code, Cursor, Codex, Windsurf, Devin — each has its own memory and rule system. A team running two agents has two incompatible rule files. Team behavior needs to travel. This is structural, not temporary.
Before agents, repeated mistakes became tooling: CI checks, runbooks, linters, deployment gates, code review norms, and platform abstractions. Now corrections happen inside agent sessions, PR comments, Slack threads, and terminal traces. That is valuable operational learning — but today it dies as text. Directionally targets the correction loop: catching repeated agent failures before they become rework, review drag, or production incidents.
Source: Entelligence Research, “Token Maxxing Is Making Engineering Teams Slower,” May 2026 — analysis of 1M+ pull requests across 2,444 engineering organizations.
Notice, redirect, show you, learn.
Watches for a familiar wrong turn: guessing, overclaiming, skipping a check, drifting from the repo, or broadening the work. One install per agent — CLI wrapper or project hook.
Nudges the agent toward a better next move — look first, run the test, check the real runtime, narrow the change, or name the assumption — before work goes off-track.
A short receipt: what the agent was about to do, what it did instead, and the evidence behind the change — and whether the user accepted it.
Keep the instincts that helped, quiet the ones that didn’t. Accepted receipts strengthen packs; rejected ones correct over-firing, and the correction compiler sharpens with every intervention.
Agents repeat mistakes. Directionally turns corrections into reusable behavior packs. The pack changes the next risky action. Receipts prove which instincts worked.
Explore free. Keep what earns its place. Expand to a team.
| Tier | Price | Job |
|---|---|---|
| Explore Mode | 7 days free · no card | The full library on your own work — decide after you see what it caught |
| Starter | $99/year · or $12/mo | Keep the instincts worth keeping — one developer’s agent |
| Pro | $399/year · 2 seats (+$149 each) · or $49/mo | Share corrections, receipts, and project instincts across a small team |
| Custom | $599+/year | Tuned to your workflow, repos, and trust requirements — founder-led setup |
There is no free tier and no forever-free plan. Explore Mode is the whole product for 7 days with no card, granted inside the agent — so the first thing a developer feels is a real catch on their own work, not a paywall. Annual-first pricing keeps Directionally cheap next to the primary agent subscription it rides on. Starter is the individual entry motion; Pro and Custom workspaces are the expansion motion, pulled by individual habit rather than sold top-down.
Start with individual developers. Expand when their behavior packs become team assets.
“My agent just did the thing I told it not to do last week.”
The first buyer is not the VP Eng. It is the developer who already trusts agents enough to be hurt by them. Start Explore Mode, feel it catch something on real work, keep the instincts that earned their place. No procurement, no champion. Team revenue follows individual habit.
The commercial loop
We are not asking developers to believe a new category before using it. We are asking them to start Explore Mode, feel one useful intervention on their real work, and keep it when repeated agent mistakes become obviously expensive.
We start in coding because this is the terrain we know best — infrastructure, developer tooling, open-source systems, and applied agent workflows — and because coding-agent mistakes are visible. The same correction pattern later appears in deploys, security review, support ops, and compliance.
Every catch receipt is product proof, marketing artifact, and distribution primitive.
The first installs come from showing real agent mistakes avoided, not from paid acquisition. Public receipts create demand before the sales motion starts.
Initial distribution wedge
- Public catch receipts — short before/after traces showing a real agent mistake avoided. Every catch is product proof, marketing artifact, and pack signal.
- Founder-led installs — hands-on setup with agent-heavy developers already using Claude Code, Codex, Cursor, and other coding agents.
- Community launches — coding-agent Discords, GitHub and X posts, and technical writeups on named failure patterns.
- Pack-led content — named behaviors like “Empty Recall Is Not Validation” and “Data Destruction Needs A Noun” as discoverable content.
- Design-partner outreach — teams already running multiple coding agents across repos.
Individual developers pull team workspaces. Team workspaces pull design-partner pilots. Distribution and product prove each other.
The moat is not the pack text. It is the receipt history.
Rules can be copied. Intervention outcomes cannot.
A copied rule does not include its firing history, acceptance rate, false-positive contexts, runtime traces, or team-specific corrections. Directionally learns which interventions actually changed real agent behavior — across real repos, real tasks, real teams. That dataset compounds with every session.
Why runtime vendors do not erase this
Runtime vendors will add better memory, rules, and team settings inside their own agents. That helps single-agent teams.
But agent-heavy teams will not standardize on one runtime. They will run Claude Code, Cursor, Codex, Windsurf, CI agents, review agents, deploy agents, and internal tools at the same time.
The valuable asset is not a rule inside one agent. It is team-owned intervention history: what fired, what changed, what was accepted, what over-fired, and what transferred across repos and runtimes.
Directionally sits above runtime memory: portable behavior packs, intervention receipts, and team-owned learning history.
Early moat
Pack quality from real agent failures. Distribution into agent-heavy developers. Speed of iteration from receipts.
Long-term moat
Intervention history owned by the team, not any runtime vendor. Private corrections no generic provider can access.
Correction compiler
Turning messy human feedback into behavior packs that fire at the right time — and not when they shouldn’t — improves with thousands of accepted receipts.
Cross-runtime position
Packs travel across Claude Code, Cursor, Codex, and what comes next. Not trapped inside any one vendor’s agent.
The missing layer is action-change.
| Category | What it does | Why Directionally is different |
|---|---|---|
| Guardrails / policy | Block prohibited outputs or actions | Directionally redirects into better work — it is not primarily a blocker, and it learns from accepted and rejected interventions |
| Agent skills | Package local capabilities or task procedures | Skills teach what an agent can do. Directionally packages corrected failure patterns and records whether the intervention worked |
| Runtime rules | Static instructions in one agent environment | Runtime-specific, don’t travel, no record of what changed |
| Runtime vendors | Add native memory, prompt tuning, team settings, and guardrails inside one agent | Useful inside one runtime. Directionally preserves team judgment across agents, records whether interventions worked, and makes behavior portable across tools |
| Memory / RAG | Recalls past context for better answers | Optimized for recall, not changing the next action |
| Observability | Logs what the agent did after the fact | Observability without control is autopsy |
Observability tells you what happened. Directionally changes what happens next.
The behavior loop is built. The commercial loop launches now.
Built
Now proving
The round creates the operating window for conversion: stabilize the company, launch, acquire early users, onboard customers, compile packs, support first paid teams, and expand into workspaces. Explore Mode and annual checkout launch with the first public conversion loop.
The next 90 days de-risk the commercial loop.
The product bet is built around five proof questions. The round funds this cycle — not an open-ended build phase.
Will external developers install a behavior pack into their agent workflow?
Will the pack catch real failures in real repos — not just in controlled tests?
Will users accept the intervention instead of disabling it?
Will accepted catches convert into paid individual subscriptions?
Will paid individuals pull team workspace pilots?
Each question has a measurable answer within 90 days. If all five hold, the seed raise becomes evidence-driven. If one breaks, we will know whether the problem is distribution, precision, pricing, or team expansion.
$200k to stabilize the company and produce seed-ready proof in 90 days.
Post-money SAFE · $5M cap · 10% discount · $10k minimum ticket
Directionally is raising $200k to create the operating window for a focused 90-day commercial proof cycle: stabilize the company, launch Explore Mode and the annual plans, convert early users, support first paid teams, and turn real catches into the evidence needed for a credible seed raise. Use of funds: launch, focused acquisition, pack compilation, onboarding, founder-led sales, customer success, payments/invoicing, team workspace conversion, and operational/legal support.
| 90-day proof target | Base case | Breakout case |
|---|---|---|
| Developer installs | 500 | 1,500+ |
| Weekly active users | 100 | 400+ |
| Accepted intervention receipts — a catch that changed an agent action and was accepted by the user | 150 | 750+ |
| Paid individual subscribers | 50 | 150+ |
| Cash collected — money in the bank within 90 days; individual subs prove the loop, Pro and Custom pilots drive the cash | $10k–$25k | $40k–$75k |
| Contracted pilot value — total signed value (ACV), may extend beyond 90 days | $25k | $100k+ |
| Qualified team conversations | 10 | 30+ |
| Paid workspaces / pilots | 2–3 | 8–12 |
The bet: repeated agent failures can be caught, compressed into reusable behavior, and sold as individual and team software.
Built by technical operators who have lived the agent failure loop.
Carsten Munk — product, architecture, and technical customer development. Shipped systems infrastructure, open-source tooling, and developer platforms at MeeGo, Jolla/SailfishOS, Cartesi, and Zippie. Has worked at the layer where operational mistakes become durable systems: checks, defaults, runbooks, platform conventions, and developer workflows. Directionally came from seeing agents create the same learning loop — but without a durable place for the correction to live. The fix is not a longer prompt. It is a portable behavior layer.
Nyakio Maina — engineering, operations, and customer execution. Builds across the product and owns the operating loop around first users: onboarding, follow-up, receipt review, conversion, and team-account development. Brings the execution discipline needed to turn early technical usage into a repeatable business motion.
Extended team reach
Access to a small operating network across systems engineering, open source, agent tooling, startup operations, and legal/commercial support.
This gives Directionally extra execution surface where it matters now: pack development, onboarding, receipt review, payments, company setup, and investor readiness — without overstating who is formally on the team.
Why this team
We are building from direct experience with the pattern Directionally is productizing: repeated technical failures becoming reusable infrastructure. We can build the behavior layer, extract real failures into usable packs, sell technically to engineering-heavy users, onboard early teams, handle payments and operations, and turn every customer interaction into sharper agent instincts.
Example behavior unit
Empty Recall Is Not Validation
One-line frames
Category frame
Software has packages for code reuse. Agents need packages for judgment reuse — instincts that travel across tools and compound with every correction.
Investor frame
Directionally is the behavior-pack layer for AI agents.
Developer frame
Install a pack into your agent before it repeats the same mistake.
Moat frame
Rules can be copied. Intervention outcomes cannot.
Contrast frame
Observability tells you what happened. Directionally changes what happens next.