Quickstart

This page walks you through Actx0 for the first time. First you set things up in the dashboard: a workspace, a plan, and an access key. Then you pick a client — Pctx0 (Python), Nctx0 (Node.js), Gtcx0 (Go), cURL, or Acli — and do four things:

Send a chat message (Actx0 turns it into a memory)
Search those memories
Upload a document and search it
Save a prompt and load it by name

That is the same path your agent will use in production.

Create a workspace

Sign in at app.actx0.com. If you are new, register with email, GitHub, or Google.Open Workspaces, create a workspace, and copy its id. Everything below is scoped to that workspace.

Choose a plan

Open Billing and pick a plan. Hobby is free with basic limits. Starter, Growth, and Pro raise capacity for agents, sessions, memories, documents, prompts, API calls, and AI usage (extraction and search).For this guide, use a paid plan so you do not hit Hobby limits mid-way. Manage payment later from the same Billing page.

Create an access key

Open Settings → Access keys and create a key. Grant permissions for agents, sessions, messages, memories, prompts, and knowledge (create, list, get, query, update, delete as listed).Copy the secret immediately — it is shown only once. Send it as X-Access-Key. Keep it on the server, never in a browser or git.

export ACTX0_ACCESS_KEY="YOUR_ACCESS_KEY"
export ACTX0_WORKSPACE_ID="YOUR_WORKSPACE_ID"

Install a client

Python
Node.js
Go
cURL
Acli

uv add pctx0
# or: pip install pctx0

from pctx0 import Pctx0Client

client = Pctx0Client(
    access_key="YOUR_ACCESS_KEY",
    workspace_id="YOUR_WORKSPACE_ID",
)

npm install @actx0/nctx0

import { Nctx0Client } from "@actx0/nctx0";

const client = new Nctx0Client({
  accessKey: "YOUR_ACCESS_KEY",
  workspaceId: "YOUR_WORKSPACE_ID",
});

go get github.com/Actx0/Gctx0

client := gctx0.NewClient(
  gctx0.WithAccessKey("YOUR_ACCESS_KEY"),
  gctx0.WithWorkspaceId("YOUR_WORKSPACE_ID"),
)
defer client.Close()
ctx := context.Background()

export ACTX0_ACCESS_KEY="YOUR_ACCESS_KEY"
export ACTX0_WORKSPACE_ID="YOUR_WORKSPACE_ID"

go install github.com/Actx0/Acli/cmd/acli@latest

export ACTX0_ACCESS_KEY="YOUR_ACCESS_KEY"
export ACTX0_WORKSPACE_ID="YOUR_WORKSPACE_ID"
acli status

Create an agent and session

An agent owns conversations. A session is one run — use an external id you already have (demo-1, a user id, a ticket number).

Python
Node.js
Go
cURL
Acli

agent = client.agent.create(
    name="Support bot",
    description="Handles customer tickets",
)

session = client.session.create(
    agent.id,
    external_id="demo-1",
    title="Demo session",
)

const agent = await client.agent.create({
  name: "Support bot",
  description: "Handles customer tickets",
});

const session = await client.session.create(agent.id, {
  externalId: "demo-1",
  title: "Demo session",
});

agent, err := client.Agent.Create(ctx, "Support bot", "Handles customer tickets", gctx0.AgentWriteOptions{})
session, err := client.Session.Create(
  ctx,
  agent.Id,
  gctx0.SessionLookup{ExternalID: "demo-1"},
  "Demo session",
)

curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/agents" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name": "Support bot", "description": "Handles customer tickets"}'

# copy agent id, then:
curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/agents/$AGENT_ID/sessions?id=demo-1" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"title": "Demo session"}'

acli agent create "Support bot" --description "Handles customer tickets"
acli session create --agent-id "$AGENT_ID" --external-id demo-1 --title "Demo session"

Save a user message

Post the user’s turn. Actx0 stores it, indexes it, and extracts a memory in the background (greetings are skipped; useful facts become long_lived or short_lived). Assistant replies do not trigger extraction.

Python
Node.js
Go
cURL
Acli

message = client.message.create(
    agent.id,
    session.id,
    {"role": "user", "content": "I prefer dark mode in the dashboard"},
)

const message = await client.message.create(agent.id, session.id, {
  role: "user",
  content: "I prefer dark mode in the dashboard",
});

message, err := client.Message.Create(ctx, agent.Id, session.Id, gctx0.MessageInput{
  Role:    gctx0.MessageRoleUser,
  Content: "I prefer dark mode in the dashboard",
})

curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/agents/$AGENT_ID/sessions/$SESSION_ID/messages" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"role": "user", "content": "I prefer dark mode in the dashboard"}'

acli message create "I prefer dark mode in the dashboard" \
  --agent-id "$AGENT_ID" \
  --session-id "$SESSION_ID" \
  --role user

Search memories

Wait a few seconds for extraction, then search with the next user question. Put the hits in your model prompt.You can also write a memory yourself when you already know the fact (kind: summary, fact, preference, short_lived, long_lived).

Python
Node.js
Go
cURL
Acli

hits = client.memory.search(
    agent.id,
    session.id,
    query="UI preferences",
    limit=10,
)

memory = client.memory.create(
    agent.id,
    session.id,
    {"kind": "preference", "content": "User prefers dark mode"},
)

const hits = await client.memory.search(agent.id, session.id, {
  query: "UI preferences",
  limit: 10,
});

const memory = await client.memory.create(agent.id, session.id, {
  kind: "preference",
  content: "User prefers dark mode",
});

hits, err := client.Memory.Search(ctx, agent.Id, session.Id, "UI preferences", 10)
memory, err := client.Memory.Create(ctx, agent.Id, session.Id, gctx0.MemoryInput{
  Kind:    gctx0.MemoryKindPreference,
  Content: "User prefers dark mode",
})

curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/agents/$AGENT_ID/sessions/$SESSION_ID/memories/search" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"query": "UI preferences", "limit": 10}'

curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/agents/$AGENT_ID/sessions/$SESSION_ID/memories" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"kind": "preference", "content": "User prefers dark mode"}'

acli memory search "UI preferences" --agent-id "$AGENT_ID" --session-id "$SESSION_ID" --limit 10
acli memory add "User prefers dark mode" --agent-id "$AGENT_ID" --session-id "$SESSION_ID" --kind preference

Upload knowledge and search it

Knowledge is workspace-wide (FAQs, policies), not session memory. Upload UTF-8 .txt or .md (max 2 MB). Wait until status is indexed, then search.

Python
Node.js
Go
cURL
Acli

doc = client.knowledge.upload(
    file="notes.md",
    title="Onboarding notes",
    labels={"tag": "docs"},
)

chunks = client.knowledge.search(
    query="onboarding checklist",
    limit=10,
)

const doc = await client.knowledge.upload({
  file: "notes.md",
  title: "Onboarding notes",
  labels: { tag: "docs" },
});

const chunks = await client.knowledge.search({
  query: "onboarding checklist",
  limit: 10,
});

doc, err := client.Knowledge.Upload(ctx, "notes.md", "Onboarding notes", map[string]string{"tag": "docs"})
chunks, err := client.Knowledge.Search(ctx, "onboarding checklist", nil, 10)

curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/documents" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Accept: application/json" \
  -F "title=Onboarding notes" \
  -F "[email protected]" \
  -F 'labels=["tag=docs"]'

curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/documents/search" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"query": "onboarding checklist", "limit": 10}'

acli knowledge upload notes.md --title "Onboarding notes" --label tag=docs
acli knowledge search "onboarding checklist" --limit 10

Store a prompt and fetch it

Save the system prompt in the workspace. At runtime, fetch by handle: production for live traffic, latest while you iterate.

Python
Node.js
Go
cURL
Acli

prompt = client.prompt.create(
    name="Support system prompt",
    type="text",
    content="You are a helpful support agent. Address the user as {{user_name}}.",
    description="Primary system prompt",
    production=True,
)

live = client.prompt.get_by_name("support-system-prompt", version="production")

const prompt = await client.prompt.create({
  name: "Support system prompt",
  type: "text",
  content: "You are a helpful support agent. Address the user as {{user_name}}.",
  description: "Primary system prompt",
  production: true,
});

const live = await client.prompt.getByName("support-system-prompt", {
  version: "production",
});

prompt, err := client.Prompt.Create(
  ctx,
  "Support system prompt",
  gctx0.PromptTypeText,
  "You are a helpful support agent. Address the user as {{user_name}}.",
  gctx0.PromptWriteOptions{Description: "Primary system prompt"},
)
live, err := client.Prompt.GetByName(ctx, "support-system-prompt", "production")

curl -X POST "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/prompts" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "name": "Support system prompt",
    "type": "text",
    "content": "You are a helpful support agent. Address the user as {{user_name}}.",
    "description": "Primary system prompt",
    "production": true
  }'

curl -X GET "https://app.actx0.com/api/v1/workspaces/$ACTX0_WORKSPACE_ID/promptsByName/support-system-prompt?version=production" \
  -H "X-Access-Key: $ACTX0_ACCESS_KEY" \
  -H "Accept: application/json"

acli prompt create "Support system prompt" \
  --type text \
  --content "You are a helpful support agent. Address the user as {{user_name}}." \
  --description "Primary system prompt"
acli prompt get-by-name support-system-prompt --version production

Before each model reply: fetch the prompt, search memories (and knowledge if the question is about your docs), then generate.

Keep access keys server-side. Never expose them in browser or mobile clients.

Next steps

Platform overview

How messages become memories

Agents

Sessions, messages, and scope

Knowledge

Documents, labels, and search

API Reference

Full REST surface and SDK samples

​Quickstart

​Next steps

Platform overview

Agents

Knowledge

API Reference

Quickstart

Next steps