Invokta

Your users already chose their agent

A customer should not have to adopt your proprietary agent to use a valuable product capability. An internal team should not have to rebuild the same process when it moves between agent clients. Both need the domain action to remain independent of the interface that invokes it.

Invokta is the TypeScript framework for building agent-ready software around Action Engines: versioned, headless capabilities that MCP-compatible agents, applications, CLIs, and automations can invoke. Headless means the capability is callable without forcing the user through your UI.

For example, a calendar API can create an event. An Appointment Scheduling Engine can expose appointments.schedule, check authorization and clinic rules, revalidate a slot, write through the authorized calendar connector, and return either a confirmation or a stable conflict.

Users keep their preferred agent while your product continues to own the action’s contract, tools, data access, validation, and result.

Several example consumers invoke the same domain action. Changing the agent or interface does not rebuild its providers, scripts, data, templates, permissions, contracts, or rules.

One product capability, every published channel

A useful product capability or internal process often begins inside one UI, agent configuration, prompt, or skill. The next agent or application receives another copy of its tools, instructions, permissions, validation, and error handling.

Preparing a ticket for implementation, for example, may require intent from Linear or Jira, repository context, architecture decisions, Figma designs, and internal engineering rules. Without an owned action, every harness receives the same tool setup and another copy of the instructions:

Cursor      -> Linear MCP + GitHub MCP + Figma MCP + planning skill
Claude Code -> Linear MCP + GitHub MCP + Figma MCP + copied skill
Codex       -> the same setup + another version of the instructions

The first setup ships quickly. The copies then drift: tools are called differently, permissions and validation change, and each agent may produce a different result.

Invokta turns that process into one reusable action:

Cursor ───────┐
Claude Code ──┤
Codex ────────┤
CLI ──────────┼──> engineering.prepare-implementation
Application ──┘                  |
                                  ├── ticket intent
                                  ├── repository context
                                  ├── architecture
                                  ├── design
                                  ├── engineering rules
                                  └── implementation-ready brief

The action owns its integrations, rules, permissions, validation, and output contract. Every consumer reaches the same implementation through application code, the CLI, MCP stdio, or stateless MCP Streamable HTTP.

MCP provides access to an owned capability

MCP gives compatible agents a standard way to discover and call tools. Invokta keeps the domain behavior behind that tool in one versioned Action Engine that also serves application code and the CLI.

Agent-ready products and harness-agnostic teams

The same boundary applies whenever a team repeatedly reconstructs context, provider calls, scripts, templates, rules, and expected output for different agents or applications.

Software products

Let customers use product capabilities from their preferred MCP-compatible agent while your product keeps the contract, permissions, and domain rules.

Explore software product use cases

Content and creative

Build a Video Production Engine around ElevenLabs STT, Cartesia TTS, GPT Image 2.0, Seedance 2.0, and trusted editing scripts—or a Social Carousel Engine that already knows your formats, CTA policy, and visual system.

Explore content and creative use cases

Engineering

Turn a ticket into implementation-ready work with repository context, architecture, design, risks, acceptance criteria, and a test strategy.

Explore engineering use cases

Marketing

Turn a product launch into an on-brand campaign using positioning, audience research, approved evidence, previous performance, and channel rules.

Explore marketing use cases

Sales

Generate a customer-specific commercial proposal from CRM context while preserving the approved template, visual identity, pricing, and claims.

Explore sales use cases

Healthcare operations

List clinic-approved appointment slots, revalidate the selected time, and write the confirmed appointment through an authorized Google Calendar adapter.

Explore scheduling use cases

People and recruiting

Apply an explicit job rubric, persist screening evidence in the recruiting system, and notify the hiring team in Slack when human review is warranted.

Explore recruiting use cases

Explore use cases by company area

We call these reusable actions Action Engines

An Action Engine packages an AI-supported domain outcome behind a stable contract, independently of the agents, applications, and interfaces that invoke it.

The implementation-ready brief, rendered video, approved carousel, commercial proposal, booked appointment, or screening result is the durable asset. MCP, CLI, HTTP, and direct APIs are delivery paths to that asset. Models, prompts, providers, scripts, templates, and interfaces can change while consumers continue to request the same outcome.

What Invokta provides

Define a capability once with its input, output, access rule, and execution behavior. Invokta applies the same invocation pipeline from application code, the CLI, MCP stdio, and stateless MCP Streamable HTTP.

Stable contracts

Validate input and output at runtime and publish the same schema information through every adapter.

One execution path

Every adapter calls engine.invoke, keeping validation, authorization, cancellation, errors, and events in one pipeline.

Delivery paths

Invoke the engine directly, expose a local CLI, or publish MCP tools over stdio and bounded stateless HTTP.

Supporting tools

Check capability composition, install engines in supported local MCP clients, and prepare reviewable HTTP deployment artifacts.

Your engine owns the outcome

Domain contracts, business rules, prompts, models, data integrations, authorization policy, evaluations, and outcome quality stay in the engine you build. Invokta does not provide an identity provider, model router, agent harness, workflow engine, or production observability platform.

The smallest useful engine

import { createEngine, defineCapability } from "@invokta/core";
import { z } from "zod";

const greet = defineCapability({
  description: "Create a welcome message for a new team member.",
  input: z.object({ name: z.string().trim().min(1) }),
  output: z.object({ message: z.string() }),
  access: "public",
  async run({ input }) {
    return { message: `Welcome, ${input.name}!` };
  },
});

export const engine = createEngine({
  name: "hello-engine",
  version: "1.0.0",
  capabilities: {
    "onboarding.create-welcome-message": greet,
  },
});

The capability ID belongs to the engine map. The capability contains the contract and implementation that every entry point reuses.

Build the complete example

Choose your next step

Find a company use case

Browse use cases by company area and identify an outcome that your agents or applications repeatedly reconstruct today.

Explore complete engines

Browse example engines for specifications, context retrieval, code review, image production, observability, and support operations.

Follow a practical recipe

Use a runnable recipe for dependency injection, domain authorization, capability composition, or an external provider.

Understand the boundary

Read about Action Engines and the capability contract.

Look up the API

Use the @invokta/core reference and the error taxonomy while implementing an engine.