Potencialize seu agente
Instalação do publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
Ainda não há uma versão empacotada no registro. Siga o README do repositório.
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDo publicador
OwlLayer AI - Open-source TypeScript Agentic UI SDK for AI-powered interfaces across React, Vue, Angular, Svelte, Vanilla JS/HTML and PHP, with tools, live context, voice and HITL security. Built for the next generation of WebMCP, NativeMCP and MCP integrations.
Most AI integrations in web applications can describe a product, but they cannot safely operate it. OwlLayer AI gives an agent a bounded, live view of what it is allowed to do in the interface that the user is currently using.
It is not a DOM scraper, a generated replacement UI, or a chatbot bolted onto an application. Your components, business rules, and existing workflows remain the source of truth.
With OwlLayer AI, an agent can:
This makes OwlLayer AI useful for guided commerce, product operations, support flows, enterprise dashboards, and voice experiences where an AI must be helpful without becoming an unrestricted automation layer.
The Model Context Protocol (MCP) is a standard for exposing tools on the server side: an MCP server declares functions (query_database, create_ticket, …) that an AI agent such as Codex or Claude Code can call.
OwlLayer AI works on the interface side: it turns the elements of your web app (buttons, links, form fields, components) into tools, and puts the agent inside the app. Your users chat with it directly in your product; they do not install or configure any agent tool.
The model is built around five concepts, deliberately independent of any UI framework or backend implementation.
Neural-DOM Binding is the connection between a living page and an LLM brain.
OwlLayer AI turns the page into a semantic surface, readable by an AI agent. Instead of making an agent hunt for a button, click it, and guess what changed, the application tells the model: these are the intentions that exist on this page, this is the context, and these are the rules for executing them.
It is not browser automation, and it is not a framework virtual DOM. The agent receives a named, typed, policy-governed intention such as add_to_cart, get_order, or approve_refund.
A tool is an action the agent can call: a name, a description the model reads, an input schema, a risk level, and a handler in your application code. The binding is declarative and lifecycle-aware, and three parts of the runtime manage it:
useAgentTool, declarative components, OwlLayer.registerTool(), or data-owllayer-tool attributes). The client sends the updated list to the server.global: true stay available for the whole session.Pick the integration style that matches your product.
Each guide covers installation, runtime setup, components, and framework-specific API details. Start from the maintained entry points:
On native mobile the equivalent is a compact, screen-scoped context: ScreenContext. The same rule applies: expose only the relevant UI state and the active tools, and keep execution inside the application owner.
OwlLayer AI separates agent reasoning, low-latency conversation, and speech services so each product can choose the right interaction model.
The runtime keeps the same capability and approval model whether a turn is text-based, uses a STT/LLM/TTS pipeline, or runs on a native realtime audio model. See the server documentation and voice guide for integration details.
Every package is published on npm. Install the server and the SDK of your front end:
npm install @owllayer/server @owllayer/adapter-google # server
npm install @owllayer/react @owllayer/core zod # front end (or vue, svelte, angular, browser)
The server connects the model, the sessions, and the approval policy. Model keys stay on the server; the browser only holds the public pk_… key.
import { OwlLayerServer } from '@owllayer/server';
import { GoogleAdapter } from '@owllayer/adapter-google';
const server = new OwlLayerServer({
llm: new GoogleAdapter({ model: 'gemini-2.0-flash', apiKey: process.env.GOOGLE_API_KEY! }),
port: 3001,
path: '/owllayer',
});
server.addApiKey('pk_live_your_public_api_key');
server.listen();
On the client, the runtime is established once, at the application root. It opens the live connection and makes agent context and tool registration available to every component below it.
import React from 'react';
import { OwlLayerProvider } from '@owllayer/react';
import MainLayout from './MainLayout';
export default function App() {
return (
<OwlLayerProvider
apiKey="pk_live_your_public_api_key"
endpoint="wss://your-server.example.com/owllayer"
config={{
voice: true,
hitl: { ui: 'modal' },
}}
>
<MainLayout />
</OwlLayerProvider>
);
}
A capability, or tool, is an action the agent can call. It is declared next to the UI it belongs to, with a description the model reads, the input schema it accepts, and the risk level that governs it. The handler is your existing application code. (Information the agent should know without acting, such as what the page shows or what the user is trying to do, is context, covered in section 7.) There are two ways to declare it: in script, for dynamic or schema-driven tools, or with declarative components for standalone elements. The examples use React; the other SDKs follow the same model.
import React from 'react';
import { useAgentTool } from '@owllayer/react';
import { z } from 'zod';
const addToCartSchema = z.object({
productId: z.string(),
qty: z.number().min(1).default(1),
});
export function ProductCatalog({ products }) {
// One tool for the entire list: the LLM selects the right product via productId.
// Listing all products in the description gives the model full awareness.
// Creating one tool per product would flood the registry with near-identical entries.
useAgentTool(
{
name: 'add_to_cart',
description: `Add a product to the cart. Available: ${
products.map((p) => `${p.id} — ${p.name} $${p.price}`).join('; ')
}`,
schema: addToCartSchema,
risk: 'low',
},
async ({ productId, qty }) => {
const product = products.find((p) => p.id === productId);
await apiAddToCart(productId, qty);
return {
success: true,
message: `${qty}× "${product?.name ?? productId}" added to cart.`,
};
},
);
return (
<ul>
{products.map((p) => (
<li key={p.id}>
{p.name} — <button onClick={() => apiAddToCart(p.id, 1)}>Add to cart</button>
</li>
))}
</ul>
);
}
Because the tool is registered on mount and released on unmount, the capability surface follows the screen the user is on. Navigating to checkout exposes a different surface: the agent never acts on a stale global command list.
The handler must return (or await) all the asynchronous work its result depends on: the result is sent to the agent only when the handler has finished. See the tools guide for good practices and anti-patterns.
Without a framework, the same declaration is imperative:
import { OwlLayer } from '@owllayer/browser';
await OwlLayer.init({ apiKey: 'pk_live_your_public_api_key', endpoint: 'wss://your-server.example.com/owllayer' });
OwlLayer.registerTool('track_order', {
description: "Show the delivery status of one of the user's orders",
parameters: {
type: 'object',
properties: { orderId: { type: 'string', description: 'Order number, e.g. A-1042' } },
required: ['orderId'],
},
risk: 'none',
handler: async ({ orderId }) => fetchOrderStatus(String(orderId)),
});
For standalone elements, each framework SDK exposes two co-location components. <OwlLayerToolBtn> renders its own <button> and registers the tool in one step: the same handler is called by the agent and by the user click. <OwlLayerTool> wraps an existing element and triggers a DOM action or a direct callback. Vue and Svelte use the same names; Angular provides <owllayer-tool-button> and the owllayerToolName directive.
React example:
import { OwlLayerToolBtn, OwlLayerTool } from '@owllayer/react';
import { Link } from 'react-router-dom';
// Self-rendered button, for a single product (e.g. a product detail page).
// The same handler is called by the user click and by the agent.
// Use context to give the agent the product details it needs.
<OwlLayerToolBtn
name="add_to_cart"
description="Add the current product to the cart"
risk="low"
handler={async () => {
await apiAddToCart(product.id, 1);
return { success: true, message: `"${product.name}" added to cart.` };
}}
context={{ productId: product.id, name: product.name, price: product.price }}
>
Add to cart
</OwlLayerToolBtn>
// Transparent wrapper: the agent clicks an existing element.
<OwlLayerTool
name="go_to_checkout"
description="Navigate to the checkout page"
risk="none"
action="click"
>
<Link to="/checkout">Checkout →</Link>
</OwlLayerTool>
Use useAgentTool when the tool needs a Zod schema, handles a list of dynamic items, or requires async business logic. Use <OwlLayerToolBtn> or <OwlLayerTool> for standalone, schema-free elements where co-location is enough.
For plain HTML or server-rendered pages without a framework, @owllayer/browser turns marked elements into tools: a button the agent can click, a form field it can fill.
<button
data-owllayer-tool="add_to_cart"
data-owllayer-description="Add the Bluetooth Pro headphones to the cart"
data-owllayer-risk="low"
>
Add to cart
</button>
<input
name="city"
data-owllayer-tool="set_shipping_city"
data-owllayer-description="Set the city of the shipping address"
data-owllayer-action="setValue"
data-owllayer-schema='{"type":"object","properties":{"value":{"type":"string"}},"required":["value"]}'
/>
data-owllayer-action accepts click (default), setValue, focus, scrollIntoView, show, hide, addClass, and removeClass. For elements created dynamically, use OwlLayer.registerTool() instead.
Context is passive information the agent reads to understand the current situation: what the page shows, what the user is trying to do, and instructions the developer wants the agent to follow on this screen. It is not a tool and triggers no action. Write it as a human-readable description: the LLM reads it as text, so explicit sentences are more useful than raw variable dumps.
import { useAgentContext } from '@owllayer/react';
function CartPage({ cart, user }) {
useAgentContext({
page: 'Shopping cart',
summary: `${user.name} has ${cart.items.length} item(s) in their cart for a total of $${cart.total}. ` +
`The cart contains: ${cart.items.map((i) => `${i.qty}× ${i.name}`).join(', ')}.`,
nextStep: 'User can confirm the order, remove items, or continue shopping.',
});
return <CartView cart={cart} />;
}
The hook re-publishes the context whenever its data changes.
Outside a framework, context is pushed imperatively whenever the page state changes. An element marked as a tool can also carry context in HTML, as JSON in data-owllayer-context.
import { OwlLayer } from '@owllayer/browser';
// Call after navigation or whenever the relevant state changes.
OwlLayer.updateContext({
page: 'Product catalog',
summary: 'User is browsing 24 headphones. Active filter: Bluetooth. Sort: Price ascending.',
});
A single turn follows the same path whether the user types or speaks. Step 5 is the boundary that matters: the agent does not implement business operations. It requests a named capability, and your application performs the work. The messages travel over AITP, a typed JSON protocol over WebSocket. It defines 14 message types, and the server checks the protocol version strictly when the connection opens.
For the complete model, read Core concepts, Architecture, and the AITP protocol.
OwlLayer AI treats AI execution as an explicit application capability, not as arbitrary automation.
none runs directly, low runs with a notification, and high and critical always wait for the user's approval before running.server.blockTool('name') blocks a tool even if a client declares it.Read the HITL security guide before exposing destructive or high-impact operations. Never place provider credentials in browser bundles. For vulnerabilities, follow SECURITY.md instead of opening a public issue.
Requirements: Node.js 22 and pnpm 9.
git clone https://github.com/borisbob91/owllayer.git
cd owllayer
pnpm install --frozen-lockfile
pnpm lint:packages
pnpm test:packages
pnpm build:packages
While developing, target a single package:
pnpm --filter @owllayer/core test
pnpm --filter @owllayer/react build
Public npm artifacts are built only from packages/. Applications, plugins, documentation sites, and local planning material are not released.
packages/: the public framework surface, with runtime packages, shared primitives, adapters, and the main integrations meant to be consumed by other projects. This is what gets published to npm.apps/: demo applications and validation environments used to exercise the framework in real scenarios. Excellent for testing behavior and UX, but not part of the published surface.packages/shopify/ and packages/woocommerce/: experimental integrations that bring voice shopping to existing storefronts. They evolve quickly and are not published to npm.packages/angular/: Angular SDK with providers, injectable service, directives, and standalone components.packages/adapter-anthropic/: Anthropic Claude adapter (text and tool calling).packages/adapter-livekit/: optional LiveKit runtime for WebRTC rooms, Gemini Live, and agent-session bridging.@owllayer/* package.OwlLayer AI is under active development. The packages are published on npm and are pre-1.0: APIs may change between minor versions, so use exact versions for production evaluation and review the changelogs when upgrading.
OwlLayer AI is available under the MIT License.
OwlLayer AI - Open-source TypeScript Agentic UI SDK for AI-powered interfaces across React, Vue, Angular, Svelte, Vanilla JS/HTML and PHP, with tools, live context, voice and HITL security. Built for
Visão geral
OwlLayer AI - Open-source TypeScript Agentic UI SDK for AI-powered interfaces across React, Vue, Angular, Svelte, Vanilla JS/HTML and PHP, with tools, live context, voice and HITL security. Built for the next generation of WebMCP, NativeMCP and MCP integrations.
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Owllayer roda localmente via stdio.
Última verificação: 2026-11-05. OwlLayer AI - Open-source TypeScript Agentic UI SDK for AI-powered interfaces across React, Vue, Angular, Svelte, Vanilla JS/HTML and PHP, with tools, live context, voice and HITL security. Built for the next generation of WebMCP, NativeMCP and MCP integrations.