Keystroke Review

Start with the pricing page, because that's where intent shows.

Hobby is free forever with $1 of included usage credit. Pro is $20 a month, and that $20 is usage credit rather than a seat fee. Agent runs and workflow runs are a cent each. Exa web search is $0.007 a search, web fetch $0.001, both disclosed as passed through at cost.

A company that publishes the price of an empty poll trigger to the third decimal isn't planning to surprise you on the invoice.

Second thing I look for: does the build look real? Public docs across quickstart, build-agents, build-workflows and integrations. A public GitHub org. A CLI that runs typecheck, test and deploy. An AGENTS.md convention and a keystroke.config.ts. That's a team shipping developer surface, not a landing page with a waitlist.

No published changelog, though. That's the one shipping signal I'd want and don't have here.

Now the part that actually decides it. This platform holds credentials for Slack, Gmail, GitHub and Stripe, and it runs a persistent browser that stays signed in across runs. That's a lot of standing access concentrated in one system.

They've clearly thought about it. Credential vault, credential scopes by organization, team and user, and credentials never exposed to the agents themselves. That's the right architecture.

But no SOC 2, ISO or HIPAA claim appears anywhere I could find, and there's no uptime figure or SLA either. I'm not calling that a failure, because the site simply doesn't say and new platforms often haven't been through audit yet. I am calling it the gate. If your security review needs a Type II report before anything touches production credentials, this stalls there and nothing else in this review matters.

Three questions I'd put to their team.

One: what does the Organization tier cost? Role-based access controls, agent guardrails, advanced spend limits and unlimited concurrency all sit behind custom pricing while everything else is self-serve. That's the tier a real deployment needs, and it's the one without a number.

Two: if we build twenty internal agents on their durable execution and trigger model, what's the exit? Deploying from our own repo means the source is ours. The runtime semantics aren't.

Three: who owns this internally? Agents that self-schedule and pause for human approval need an operator, not just a builder. Somebody has to answer the approval queue at 6pm on a Friday.

What I like strategically is the consolidation. Persistent memory, an isolated VM with file system and code execution, 1,000+ native integrations, any HTTP API from an OpenAPI spec, any MCP server, 300+ models on your own API keys, evals that run before deploy, and full run traces you can replay across agents, tools and human decisions. The usual approach is stitching five of those together yourself and owning the seams forever. Owning the seams is the expensive part, and it never shows up in the build-versus-buy spreadsheet.

Speed to value is the easiest call in the file. Free tier, $1 credit, a cent a run, 1,000+ integrations already wired. A two-person pilot costs less than a team lunch and answers the real question inside a month.

So: pilot it. Two engineers, one genuine internal workflow, 30 days, hard spend cap switched on from day one, since they support usage limits, alerts and hard stops.

Don't standardize the org on it until security has signed off on the credential model in writing and you've seen what Organization quotes at. In 18 months I want to defend this on our own run data, not on their homepage.

Look first at what they chose to build that's genuinely hard.

Durable execution, described as sleep and resume from saved state without holding a worker. That's a distributed systems problem, not a UX problem. Teams don't ship that unless somebody has run long-lived workflow infrastructure before. The evals point the same direction: typed test suites running against agents and workflows before deploy, with a pass count surfaced in-product. Treating a non-deterministic agent as something you gate with a test suite is the correct instinct, and it's still uncommon in this category.

The shape of the developer surface tells you who this was built for. AGENTS.md plus keystroke.config.ts, a CLI with typecheck, test and deploy, and deployment from your own repository. That's agents as source-controlled artifacts, reviewed in pull requests, promoted through environments. Compare it to the usual approach in the category, a canvas UI where the logic lives in a vendor database and code review has nothing to look at. If your platform team already runs CI, this drops straight in. If your people build automations by dragging boxes, it will feel heavy on day one.

The design decision I'd underline is deterministic, typed, testable workflows combined with agent steps. Pure-agent frameworks make everything probabilistic, including the parts that shouldn't be. The Stripe call. The Linear ticket. The approval gate. Mixing typed workflow steps with agent steps puts determinism exactly where correctness matters and reasoning where it doesn't. Add human-in-the-loop pauses and full replay traces across agents, workflows, tools and human decisions, and what you have is an auditable system rather than a black box that's usually right.

Integration surface is the strongest part of the picture. 1,000+ native integrations, any HTTP API from an OpenAPI spec URL, any MCP server over OAuth or API key, 300+ models on your own keys, and six external channels including Slack, Microsoft Teams, Telegram, Discord, Linear and WhatsApp. Escape hatches at every layer. The model layer matters most: bring-your-own-keys across Grok 4.5, GPT-5.6, Opus 5 and Sonnet 5 means a price change or a capability jump is a config edit, not a migration. That's the right layer to refuse lock-in on, because it's the layer that moves fastest.

Security architecture reads deliberately. Isolated VM for file system and code execution. A credential vault. Credential scopes at organization, team and user level. Credentials not exposed to the agents themselves, which matters more than it sounds, because an agent that can use a credential without reading it can't leak it into a prompt or a trace. No SOC 2 or ISO claim appears anywhere I could find and I won't score an attestation nobody has shown me. Architecture and certification are different questions. The architecture here is sound.

Three-year view, and this is where I hold back. If we build twenty internal agents on this, the code is ours and the repo is ours, but the runtime isn't. Durable execution semantics, the trigger model, and the organization registry of publishable agents, skills, tools and company context all belong to them. The registry is the real gravity well. The more company context you publish into it, the more expensive leaving becomes, and no export format is stated anywhere I could find. Portable at the source layer. Sticky at the orchestration layer. Worth negotiating before it matters, not after.

Where this sits in the landscape: it's an opinionated platform bet against a fragmented stack. Most teams building internal agents today assemble a framework, a queue, a secrets manager, an integration layer and an eval harness themselves, then maintain the joins forever. This platform's wager is that those joins should belong to one vendor with one trace view over all of them.

If that wager fits your org, adopt it deliberately. Two agents first. Keep the registry lean for six months. Get the data export clause in writing while you still have no leverage to lose.

Read the rate card first. Agent run, $0.01. Workflow run, $0.01. Empty poll trigger, $0.005. Exa web search, $0.007. Exa web fetch, $0.001. The last two are disclosed as at cost, no markup.

Five published rates. Two of them explicitly pass-through. That's more pricing detail than most platforms in this category give you after a sales call.

Pro is $20 a month, and the $20 is included usage credit. Not a seat fee. That distinction is the entire model. You're buying a prepaid meter, not a license.

Now the number that isn't on the page. Bring your own API keys, 300+ models. Model inference bills to your provider account, not to this vendor. So the $20 line and your actual AI spend are two separate invoices. That's not a trap, they state it plainly. But a budget built off the pricing page alone will be wrong, and at volume it'll be wrong by an order of magnitude.

The poll rate is where I'd model hardest. $0.005 per empty poll. One trigger polling every five minutes is 288 polls a day, 8,640 a month, $43.20. That's a single trigger, finding nothing, costing more than double the entire Pro credit. Ten of those is $432 a month before one agent has run.

Move that trigger to a one-minute interval and it's $216 a month on its own. Use webhooks and connected-app events wherever the integration supports them. Polling is the line item that gets teams.

Three-year scenario. Team of 50, moderate use. Say 15,000 agent and workflow runs a month at $0.01, that's $150. Twenty triggers, mostly webhooks, light polling, call it $100. Three thousand Exa searches at $0.007, $21. Round to $275 a month. $3,300 a year. Roughly $10K over three years on the platform itself. Model inference on your own keys sits outside that and will very likely exceed it.

Compare to per-seat agent tooling in the $20 to $40 range. Fifty seats at $30 is $18,000 a year, $54,000 over three. Usage billing wins badly when ten people build and forty consume the output. It loses when you run high-frequency automation. Volume pricing is honest right up until the volume arrives.

What I can't model is the Organization tier. Custom pricing, and it holds advanced usage and spend limits, role-based access controls, agent guardrails and unlimited concurrency. Those are precisely the controls a finance function wants before approving autonomous spend. The tier you need for governance is the one tier without a number.

Contract terms aren't stated. No auto-renewal window, no minimum term, no cancellation process, no data export format anywhere I could find. Monthly billing plus a free-forever tier plus usage pricing suggests low commitment. Suggestion isn't a term sheet. Get it in writing.

One thing deserves real credit. Usage limits, spend alerts, and hard stops before going over budget. Hard stops are the feature. Plenty of usage-priced vendors give you an alert and then an invoice. A hard ceiling means the runaway-loop scenario has a floor, and runaway loops are what kill usage-based deals in year two.

ROI is unusually measurable here. A cent per run, full run traces you can replay, and evals that pass or fail before deploy, 12 of 12 in their own example. You can attach a cost to a unit of work and a pass rate to the thing performing it. Most platforms in this category give you neither.

Procurement won't fight the first two tiers. Free forever, $20 monthly, free trial, self-serve, card-swipe scale. The third tier is a phone call.

Net: buy the meter, model the polls, and get Organization terms in writing before anything mission-critical runs on it.

Four commands in the docs tell me who built this: keystroke typecheck, keystroke test, keystroke deploy, keystroke agents prompt. Add deploy-from-your-own-repo, an AGENTS.md, a keystroke.config.ts, and eval suites that run against agents and workflows before deploy. That's a type check, a test run and a diff standing between an engineer and a bad shipment. Most things in this category hand you a canvas and let production be the test environment.

The runtime primitives are the right ones for unattended work. Durable execution that sleeps and resumes from saved state without holding a worker means a workflow waiting three days on a vendor reply isn't a pinned process. Human-in-the-loop pauses runs for review or approval before continuing. Full run traces replay across agents, workflows, tools and human decisions, which is the most useful thing you can have at 2am when an agent did something inexplicable. And typed deterministic workflows composed with agent steps is the hybrid shape that actually works - pure-agent systems are unrepeatable, pure-workflow systems can't handle ambiguity.

Integration surface is broad on paper. 1,000+ native integrations with Slack, Gmail, Linear, Notion, GitHub and Stripe named; any HTTP API from an OpenAPI spec URL; any MCP server over OAuth or API key. The detail I'd check first is the credential model - a vault, scopes by organization, team and user, and credentials never exposed to the agents. If you're letting a model near Stripe, that isn't a nice-to-have.

Now the honest part. Nobody has used this and there are no screenshots I could find. So the day-three questions I'd normally lead with - how a failed workflow step reads in the error output, whether a 200-step trace stays navigable, how long a deploy takes, whether the CLI emits JSON for scripting - are unanswered. I'm parking Day-3 Reality and Friction Surface at neutral rather than inventing observations, which is why my overall sits above both: the dimensions I can actually answer are strong. What the docs do show is a quickstart plus separate build-agents and build-workflows paths plus an integrations reference. Three entry points for three different intents. That's the structure of docs written by someone who watched a user get stuck.

One evidenced friction worth budgeting for: empty poll triggers bill $0.005 each. A one-minute polling schedule is 43,200 polls a month, roughly $216, for triggers that found nothing. Webhooks and connected-app events are supported and cost nothing to wait on, so it's a design decision rather than a trap. Still the line I'd read twice before wiring up a schedule.

Otherwise the pricing is unusually clean. Agent run $0.01, workflow run $0.01, Exa search $0.007 and fetch $0.001 passed through at cost. Pro at $20/mo is $20 of usage credit rather than a seat fee, so five engineers on Pro is $100 of actual compute, not $100 of tax before anything has run. Hobby's $1 credit is 100 agent runs - a tutorial, not a pilot.

The ceiling is high. Multi-agent coordinators routing to specialists with context-preserving handoffs, an organization registry for publishing and reusing agents, skills, tools and company context, agents that self-schedule. That's a platform you grow into over a year rather than outgrow in a month. The tradeoff is the floor: a config file, a CLI, a repo. Nothing I could find shows a no-code path, so a non-engineer on your team isn't shipping anything here alone.

The pricing page is the part I kept rereading. Twenty dollars a month on Pro, and the twenty dollars is usage credit, not a seat fee. That's rare enough that I checked it twice. Runs cost a cent each, agent or workflow, so twenty bucks is two thousand runs. The free tier gives you a dollar. That's a hundred runs. A weekend of tinkering, then a decision. Fair enough, honestly - nobody's pretending the free tier is a business.

The thing I actually like is where the agents live. Slack, Microsoft Teams, Telegram, Discord, Linear, WhatsApp. Six places people already are. The tools that quietly die inside companies are the ones that ask everyone to open a seventh tab, every day, forever. And runs pause for human review or approval before continuing, which is the difference between an automation you check on and one you lie awake about. There are usage limits, alerts and hard stops before you go over budget too. Someone on that team has been surprised by a bill before.

Now the part where I have to be straight with you. Nobody has used this thing and there isn't a single screenshot in front of me. So I can't tell you about empty states, whether loading feels instant or laggy, whether error messages read like a human wrote them, whether it autosaves. I'm not going to make it up. Four of my five dimensions are about exactly those things, so I've parked them at neutral. My overall is about what I can actually see - the pricing, the channels, the docs, the shape of the thing.

The shape is the catch. The on-ramp is a CLI and a TypeScript config file, keystroke.config.ts, plus an AGENTS.md, deployed from your own repo. There's a quickstart in the docs and separate paths for building agents and building workflows, so the map exists. But if you're not comfortable in a terminal, your first hour is homework, not welcome. This isn't a drag-and-drop builder wearing a developer costume. It's a developer tool that happens to talk to Slack.

Mobile: the site says nothing. No app mentioned. I'm not counting that against them, because plenty of good tools are desktop-shaped and honest about it, and being able to poke an agent from WhatsApp or Telegram covers most of what I'd want from a phone anyway. It still isn't the same as a real mobile product and I won't pretend otherwise.

What would keep me here three months in: 300+ models with my own API keys. Grok 4.5, GPT-5.6, Opus 5 and Sonnet 5 are the ones shown in-product. Models get better every few weeks and the worst feeling is being stuck on last quarter's because your vendor hasn't gotten round to it. Bringing your own keys means the upgrade is yours to make. Same instinct behind persistent memory across conversations and a browser that stays signed in between runs - small things that stop you redoing setup work every single time. The 50GB of file storage on Pro is a real number too, not an asterisk.

Support-wise there's a Discord, a public GitHub org and an X account. Real places to ask a question. Priority support is listed as a Pro perk, which tells you the free-tier answer is the community. That's the deal, and at least it's stated plainly rather than buried.

Start with the sentence on the homepage. "The fastest way to build internal agents and AI systems." Fastest against what, measured how? No benchmark anywhere I could find. It's the kind of superlative that ages poorly, and it's the one line on the page with nothing underneath it.

Then the round numbers. 300+ models. 1,000+ integrations. Both vendor counts. Nothing third-party confirms either. The named integrations are the obvious ones - Slack, Gmail, Linear, Notion, GitHub, Stripe, plus Superhuman, Granola, Apollo and Attio. Ten names against a claim of a thousand. The other 990 is where the number actually lives, and category history says a long tail like that is usually thin, half-maintained, or a generic HTTP wrapper with a logo on it. They do disclose the escape hatch: any OpenAPI spec URL, any MCP server over OAuth or API key. Honest. Also a hint about how some of that thousand gets built.

"No vendor lock-in" is the claim I'd test hardest. At the model layer it holds - bring your own API keys is a real answer, and 300+ models with BYOK means nobody's holding your inference hostage. But that isn't the layer lock-in lives on. Agent behaviour sits in AGENTS.md and keystroke.config.ts, a proprietary format. Persistent memory accumulates across conversations. The organization registry holds your published agents, skills, tools and company context. Run traces hold your history. I could find no export, no self-host option, no open spec for any of it. Deploying from your own repo means you keep the source. You don't keep the memory. Eighteen months in, that's the migration bill.

Credit where it's due. Publishing per-unit rates - $0.01 an agent run, $0.01 a workflow run - and passing Exa through at $0.007 a search and $0.001 a fetch labelled "at cost" is the opposite of the usual playbook. Most of this category hides the meter behind a sales call. Pro at $20 being $20 of credit instead of a seat fee is a real position rather than a positioning statement. And the feature list is specific enough to be falsifiable: durable execution with sleep and resume, credential scoping by organization, team and user with credentials withheld from agents, typed testable workflows composed with agent steps. Vapour doesn't usually get that precise.

Watch the meter on triggers, though. Empty polls bill $0.005. You pay when nothing happened. Small number. Tells you how the pricing thinks.

Two gaps I'd want closed before routing a business process through it. No published changelog - for a platform whose value is keeping current with Grok 4.5, GPT-5.6, Opus 5 and Sonnet 5 as they ship, that's the one document I'd want, and without it release cadence is unverifiable. And "enterprise-grade security" on the Organization tier with no SOC2, ISO or HIPAA claim anywhere I could find. That phrase is doing work its footnotes don't support. The credential vault and role-based access controls are named and concrete; the umbrella phrase over them isn't.

None of this is about being small or new. Small and new is fine. Public GitHub org, docs split three ways, a Discord, a CLI with typecheck and test and deploy - that's a team maintaining something, and the evals capability suggests they expect to be held to a behaviour spec. My hesitation is narrower than the usual. The counts aren't verified. The exit isn't mapped. The superlative is unearned. Start it on something you could rebuild in a week, confirm the specific integrations you need actually work, and keep the source in your repo where they've sensibly put it.