Build production AI fast.
Keep the hard parts built in.

AUVY Synapse is the developer kit behind programmable memory, trace observability, governed orchestration, REST, SDK, CLI, and MCP, so technical teams can build on the same execution layer without boilerplate.

Start Free →Read the Docs →

npm install @auvy-synapse/client

Open docs

import { fromApiKey, createStream } from '@auvy-synapse/client'

const auvy = await fromApiKey(process.env.AUVY_API_KEY!)

const { job_id } = await auvy.receptors.invoke('my-workspace', 'my-receptor', {
  message: 'Analyze this document',
  stream: true,
})

for await (const chunk of createStream(auvy, job_id)) {
  if (chunk.type === 'token' && chunk.token) process.stdout.write(chunk.token)
}

What you do not build

Every row below is shipped, observable, and addressable through the API. You write the agent; Synapse supplies the execution layer.

You don't build

AUVY ships

Vector DB + embeddings pipeline

Hybrid search on the resource spine

RAG chains (chunk, embed, rerank)

Scoped recollections per neuron and trace

Trace store + OpenTelemetry plumbing

Engrams, traces, and activity feed

Queue runner + SSE streaming

Durable jobs with stream, cancel, resume

HITL UI + resume contract

Interventions: one pause concept everywhere

Trigger scheduler + webhook router

Cron, webhooks, and manual triggers

Code interpreter container

Managed shell and Python sandbox tools

Multi-provider model router

Model config catalog with per-run routing

What you get

Memory, traces, orchestration, integrations, and workspace controls, wired together, not bolted on.

Universal Memory

AUVY pulls context before responding, no vector DB or retrieval layer to maintain.

Execution Evidence

Inputs, tool calls, reasoning, and costs in one trace. Debug and audit without extra plumbing.

Orchestration

Branching, approvals, and subflows when you need them, without unmaintainable glue code.

Integrations

Workplace, CRM, support, and commerce systems, one execution model instead of one-off adapters.

Many more systems via connectors, webhooks, and custom APIs, same execution model.

Governance

Workspace isolation, RBAC, and exportable evidence for regulated teams.

Built on a living nervous system

Synapse ships memory, trace, orchestration, and integration primitives as real objects in the SDK and REST API.

Engrams

transcript · fork · audit

Ordered, content-addressed transcript rows. Branch a conversation, fork from any turn, audit every step.

Live connectome

brain coords · routes

A 3D semantic activity map of every brain. Rolling traffic between neurons, receptors, and pathways.

Compounding recall

auto-context · per-trace

Every thread grows its own scoped recollection. The next turn remembers what this turn touched.

Versioned graph patches

apply_pathway_patch

Pathways and stakeholder maps are immutable spine versions. Diff, revert, replay any change.

Typed delegation

send_back

Workers finish with send_back { kind, summary, data }. Parents validate the handback. No vibes.

Durable interventions

waiting_for · resume

Frozen execution snapshots survive worker restarts. One resume API across chat, pathway, and SDK.

Public receptors

public · scoped · SSE

Share-token invoke with scoped streaming. Brain memory fallback off, no vault leaks to anonymous callers.

Brain feeds

cross-brain transfer

Move knowledge between brains under typed relationships. Distribute playbooks, keep tenancy intact.

Every capability is a real object in the SDK and REST API. No black boxes, no glue code.

Read the Synapse docs →

Primitives in the API and SDK

Receptors through memory map to real objects. Open a tile for how each piece works.

Receptors Listen

Capture support tickets, inbound emails, form submissions, and internal requests the moment they arrive so urgent work is not missed.

Neurons Think

Review the situation against your policies and past decisions to classify requests, draft responses, and recommend the right next step.

Pathways Workflows

Move work through escalations, approvals, and follow-ups so teams spend less time chasing handoffs and more time closing outcomes.

Reflexes Action

Push the outcome back into the systems buyers already care about: update records, notify teams, create tasks, and trigger the next action.

Memory & Traces Record

Keep a usable record of what happened, why it happened, and who approved it so buyers get consistency and leaders get proof.

Start in the docs

Quick start first, then API reference, SDK, CLI, and MCP, all in one docs site.

Read the Docs →

Build production AI fast. Keep the hard parts built in.