What effector is, why it exists, and how it fits into the AI agent landscape.

Overview

Effector is the standard toolkit for typed AI agent tool interoperability. It adds a typed interface layer to AI agent tools — 40 standard capability types, static composition checking, and cross-runtime compilation from a single sidecar manifest.

AI agent capabilities are in the pre-TypeScript era. effector-types is the lib.d.ts for Effectors — the standard library of capability types grounded in real-world usage from 13,000+ analyzed tools.

The Problem

Every AI agent tool has an implicit interface: it takes something, produces something, and needs something from the environment. But today, these interfaces are invisible. The consequences:

Composition by prayer. You chain two MCP tools and discover at runtime that they're incompatible — after burning tokens, time, and API calls.
Runtime lock-in. MCP tools only work in MCP. LangChain tools only work in Python. Your capability definitions are trapped in one ecosystem.
Discovery by keyword. Finding a tool that produces ReviewReport from CodeDiff requires reading READMEs, not querying a type catalog.
Implicit security. Whether a tool accesses the network or filesystem is buried in implementation, not declared in metadata.

The Solution

Effector adds a typed interface layer to AI agent tools. It's a sidecar manifest — your tool keeps running exactly as before. Drop an effector.toml next to your tool:

Now your tool has:

Type-safe interfaces — input/output/context from 40 standard capability types
Static composition checking — verify tool chains before execution
Cross-runtime portability — compile to MCP, OpenAI, LangChain, or JSON
Security auditing — declared permissions vs actual behavior

How It Compares

Feature	Raw MCP	LangChain	CrewAI	effector
Type safety	None	None	None	40 standard types
Composition	Manual	Runtime only	Rigid roles	Static verification
Cross-runtime	MCP only	Python only	Python only	MCP, OpenAI, LangChain, JSON IR
Discovery	By name	By name	By name	By input/output type
Dependencies	Varies	Heavy	Heavy	Zero
Permission model	None	None	None	Declared + audited
Existing tools	N/A	Rewrite	Rewrite	Unchanged (sidecar)

The Toolchain

effector is a cohesive ecosystem of focused tools, each doing one thing well:

Tool	What it does
`@effectorhq/core`	Shared kernel — TOML parser, type checker, schema validator, compiler
`create-effector`	Scaffold new capabilities in seconds with interactive prompts
`@effectorhq/skill-lint`	Validate SKILL.md structure, frontmatter, and section coverage
`@effectorhq/audit`	Security analysis — permission mismatches, undeclared access, trust scores
`@effectorhq/compose`	Static pipeline builder — verify type compatibility between tools
`@effectorhq/graph`	Interactive dependency graph (D3 force layout, spectrum, dashboard)
`@effectorhq/skill-eval`	Quality scoring (0-100) across 10 weighted dimensions
`effector-studio`	Visual editor for building manifests with compile target preview

Architecture

effector.toml + SKILL.md  (your capability definition)
        │
        ├── validate  →  schema validator + type checker
        ├── lint      →  SKILL.md structure checks
        ├── audit     →  permission + trust analysis
        ├── compose   →  type-based pipeline verification
        ├── compile   →  MCP / OpenAI / LangChain / JSON IR
        └── graph     →  dependency visualization

All tools share @effectorhq/core as a kernel. Every module uses only Node.js built-ins — zero external dependencies, zero supply chain risk.

Next Steps

Installation — get started in 30 seconds
Your First Manifest — build an effector.toml from scratch
Type System — understand the 40-type catalog
Playground — validate manifests live in your browser