AI API

Era, your assistant, and the AI agents you save — they work across every module.

Module code ai · 86 actions · 29 data models · 76 events. A key or token never does more here than the person behind it can; row-level security applies exactly as in the app. Scopes: ai (everything), ai:read (read only) or ai:<capability>.

Resources

Lists take limit (up to 200), cursor, order (e.g. -created_at), fields and q; every other query parameter is a column filter: ?status=paid, ?total[gte]=100, ?id[in]=a,b, ?x=null.

Actions

ai.archive_brain

Archive a brain — Stops using a brain; what it knows stays in its history. The company brain stays.

Needs ai:manage · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.archive_brain

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.brain_archived

What it writes: brain (update) — Archives the brain; brain_binding (delete) — Disconnects it from every Era and workflow

curl -X POST https://app.getera.io/api/v1/brains/actions/archive_brain \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"id":"ID_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.brain_archived"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.brains.archiveBrain({
  id: "ID_ID"
})

era brains archive_brain \
  --id "ID_ID"

{
  "name": "era__ai__archive_brain",
  "arguments": {
    "id": "ID_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 brain_not_found, not_your_brain, archived, default_brain · 429 slow down

ai.archive_knowledge_base

Archive a knowledge space — Stops filling and reading a space; what it holds stays in its history.

Needs ai:manage · reaches outside (sends, publishes or charges) · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.archive_knowledge_base

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.knowledge_base_archived

What it writes: knowledge_base (update) — Archives the space; brain_binding (update) — Takes it out of every connection that named it

curl -X POST https://app.getera.io/api/v1/knowledge_bases/actions/archive_knowledge_base \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"id":"ID_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.knowledge_base_archived"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.knowledgeBases.archiveKnowledgeBase({
  id: "ID_ID"
})

era knowledge_bases archive_knowledge_base \
  --id "ID_ID"

{
  "name": "era__ai__archive_knowledge_base",
  "arguments": {
    "id": "ID_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 knowledge_base_not_found, archived, default_knowledge_base · 429 slow down

ai.assign_task

Hand a task over — Gives the task to a person or an agent, with a note. Handing it to an agent wakes it; an agent hands back the same way.

Needs ai:write · changes data

• Canonical address: POST /api/v1/actions/ai.assign_task

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.task_assigned, ai.agent_requested

What it writes: ai_task (update) — Moves the task and appends the handoff

curl -X POST https://app.getera.io/api/v1/ai_tasks/AI_TASK_ID/actions/assign_task \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"assigneeUserId":"APP_USER_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.task_assigned",
    "ai.agent_requested"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiTasks.assignTask("AI_TASK_ID", {
  assigneeUserId: "APP_USER_ID"
})

era ai_tasks assign_task AI_TASK_ID \
  --assignee-user-id "APP_USER_ID"

{
  "name": "era__ai__assign_task",
  "arguments": {
    "id": "AI_TASK_ID",
    "assigneeUserId": "APP_USER_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found, not_member, unknown_agent, agent_disabled · 429 slow down

ai.bind_brain

Give a brain to an Era, workflow or voice agent — Chooses which brain and spaces it knows from, and whether it may teach the brain what it learns.

Needs ai:manage · changes data

• Canonical address: POST /api/v1/actions/ai.bind_brain

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.brain_bound

What it writes: brain_binding (upsert) — Connects the brain (or changes its spaces and access)

curl -X POST https://app.getera.io/api/v1/brain_bindings/actions/bind_brain \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"subjectType":"For","subjectId":"Which one","brainId":"BRAIN_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.brain_bound"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.brainBindings.bindBrain({
  subjectType: "For",
  subjectId: "Which one",
  brainId: "BRAIN_ID"
})

era brain_bindings bind_brain \
  --subject-type "For" \
  --subject-id "Which one" \
  --brain-id "BRAIN_ID"

{
  "name": "era__ai__bind_brain",
  "arguments": {
    "subjectType": "For",
    "subjectId": "Which one",
    "brainId": "BRAIN_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 bad_subject, brain_not_found, not_your_brain, archived, personal_brain, agent_not_found, subject_not_found, knowledge_base_not_in_brain · 429 slow down

ai.check_budget

Check the AI budget — Answers whether a run may start, with the spend per cap. Era’s front door calls it before every turn; it raises the alert when a threshold is crossed.

Needs ai:read · changes data

• Canonical address: POST /api/v1/actions/ai.check_budget

Input

Events it publishes: ai.budget_alert

What it writes: ai_budget (update) — Stamps the alert key so an alert fires once

curl -X POST https://app.getera.io/api/v1/ai_budgets/actions/check_budget \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"agentId":"AI_AGENT_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.budget_alert"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiBudgets.checkBudget({
  agentId: "AI_AGENT_ID"
})

era ai_budgets check_budget \
  --agent-id "AI_AGENT_ID"

{
  "name": "era__ai__check_budget",
  "arguments": {
    "agentId": "AI_AGENT_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:read · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 429 slow down

ai.clear_budget

Remove an AI budget — Removes the cap. Spending is then unlimited for that scope.

Needs ai:manage · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.clear_budget

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.budget_updated

What it writes: ai_budget (delete) — Removes the cap

curl -X POST https://app.getera.io/api/v1/ai_budgets/AI_BUDGET_ID/actions/clear_budget \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.budget_updated"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiBudgets.clearBudget("AI_BUDGET_ID")

era ai_budgets clear_budget AI_BUDGET_ID

{
  "name": "era__ai__clear_budget",
  "arguments": {
    "id": "AI_BUDGET_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found · 429 slow down

ai.close_code_session

Close the coding session — Ends the live coding session; the next request starts a new one.

Needs ai:handle · changes data

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.code_session_closed

What it writes: code_session (update) — Marks it closed

curl -X POST https://app.getera.io/api/v1/actions/ai.close_code_session \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"id":"CODE_SESSION_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.code_session_closed"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.actions.run("ai.close_code_session", {
  id: "CODE_SESSION_ID"
})

era ai close_code_session \
  --id "CODE_SESSION_ID"

{
  "name": "era__ai__close_code_session",
  "arguments": {
    "id": "CODE_SESSION_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found · 429 slow down

ai.complete_task

Complete a task — Marks it done. A repeating task writes its next occurrence.

Needs ai:write · changes data

• Canonical address: POST /api/v1/actions/ai.complete_task

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.task_completed

What it writes: ai_task (update) — Marks it done; ai_task (insert) — Writes the next occurrence of a repeating task

curl -X POST https://app.getera.io/api/v1/ai_tasks/AI_TASK_ID/actions/complete_task \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.task_completed"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiTasks.completeTask("AI_TASK_ID")

era ai_tasks complete_task AI_TASK_ID

{
  "name": "era__ai__complete_task",
  "arguments": {
    "id": "AI_TASK_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found, already_done · 429 slow down

ai.connect_subscription

Connect my own AI subscription — Records a person’s own AI subscription sign-in (Claude, ChatGPT, Antigravity, Grok, Copilot, Cursor …) so their chat, Eras and workflows use their plan first. A cloud sign-in is sealed in the vault; a computer sign-in stays on that computer.

Needs ai:write · changes data

• Canonical address: POST /api/v1/actions/ai.connect_subscription

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.subscription_connected

What it writes: ai_provider (upsert) — Writes the person’s own connection row (never a token)

curl -X POST https://app.getera.io/api/v1/ai_providers/actions/connect_subscription \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"provider":"claude_code","execution":"remote"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.subscription_connected"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiProviders.connectSubscription({
  provider: "claude_code",
  execution: "remote"
})

era ai_providers connect_subscription \
  --provider "claude_code" \
  --execution "remote"

{
  "name": "era__ai__connect_subscription",
  "arguments": {
    "provider": "claude_code",
    "execution": "remote"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 unknown_subscription, bad_secret_ref, device_required · 429 slow down

ai.create_agent

Create an agent — Saves a brief and a tool budget. It arrives switched off.

Needs ai:manage · changes data

• Canonical address: POST /api/v1/actions/ai.create_agent

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.agent_created

What it writes: ai_agent (insert) — Writes the agent

curl -X POST https://app.getera.io/api/v1/ai_agents/actions/create_agent \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"name":"Name"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.agent_created"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiAgents.createAgent({
  name: "Name"
})

era ai_agents create_agent \
  --name "Name"

{
  "name": "era__ai__create_agent",
  "arguments": {
    "name": "Name"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 empty_name, bad_modules, bad_trigger · 429 slow down

ai.create_brain

Create a brain — A new brain with its own knowledge spaces — for the company, one person, an Era or a voice agent.

Needs ai:manage · changes data

• REST alias: POST /api/v1/brains
• Canonical address: POST /api/v1/actions/ai.create_brain

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.brain_created

What it writes: brain (insert) — Creates the brain; knowledge_base (insert) — Creates its first knowledge spaces; brain_binding (insert) — A team brain is given to its team

curl -X POST https://app.getera.io/api/v1/brains/actions/create_brain \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"name":"Name"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.brain_created"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.brains.create({
  name: "Name"
})

era brains create \
  --name "Name"

{
  "name": "era__ai__create_brain",
  "arguments": {
    "name": "Name"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 empty_name, name_taken, not_your_brain, missing_scope_ref, agent_not_found, team_not_found, invalid_learn_from · 429 slow down

ai.create_knowledge_base

Add a knowledge space — A new space inside a brain — Sales, Product docs, Customer success, Personal notes.

Needs ai:manage · changes data

• REST alias: POST /api/v1/knowledge_bases
• Canonical address: POST /api/v1/actions/ai.create_knowledge_base

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.knowledge_base_created

What it writes: knowledge_base (insert) — Creates the space

curl -X POST https://app.getera.io/api/v1/knowledge_bases/actions/create_knowledge_base \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"brainId":"BRAIN_ID","name":"Name"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.knowledge_base_created"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.knowledgeBases.create({
  brainId: "BRAIN_ID",
  name: "Name"
})

era knowledge_bases create \
  --brain-id "BRAIN_ID" \
  --name "Name"

{
  "name": "era__ai__create_knowledge_base",
  "arguments": {
    "brainId": "BRAIN_ID",
    "name": "Name"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 brain_not_found, not_your_brain, archived, empty_name, name_taken · 429 slow down

ai.create_task

Create a task — A to-do for a person or an agent, with a due date, priority, list and repeat rule. Given to an agent, it wakes the agent.

Needs ai:write · changes data

• Canonical address: POST /api/v1/actions/ai.create_task

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.task_created, ai.agent_requested

What it writes: ai_task (insert) — Writes the task

curl -X POST https://app.getera.io/api/v1/ai_tasks/actions/create_task \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"title":"Title"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.task_created",
    "ai.agent_requested"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiTasks.createTask({
  title: "Title"
})

era ai_tasks create_task \
  --title "Title"

{
  "name": "era__ai__create_task",
  "arguments": {
    "title": "Title"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 empty_title, not_member, unknown_agent, agent_disabled · 429 slow down

ai.decide_computer_step

Approve or refuse a computer step — Answers the step the computer is waiting on. “Allow similar” approves the same kind of step on the same site for 15 minutes.

Needs ai:handle · changes data

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: computer_session (update) — Stores the decision for the worker; computer_session_event (insert) — Records who decided

curl -X POST https://app.getera.io/api/v1/actions/ai.decide_computer_step \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"id":"COMPUTER_SESSION_ID","approvalId":"APPROVAL_ID","decision":"approve"}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.actions.run("ai.decide_computer_step", {
  id: "COMPUTER_SESSION_ID",
  approvalId: "APPROVAL_ID",
  decision: "approve"
})

era ai decide_computer_step \
  --id "COMPUTER_SESSION_ID" \
  --approval-id "APPROVAL_ID" \
  --decision "approve"

{
  "name": "era__ai__decide_computer_step",
  "arguments": {
    "id": "COMPUTER_SESSION_ID",
    "approvalId": "APPROVAL_ID",
    "decision": "approve"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found, no_pending_approval · 429 slow down

ai.decide_learning

Answer what Era asked to keep — Approve (optionally re-worded, re-filed, with an end date) or reject. Approving keeps the memory — confirmed, with where it came from — or makes the skill live as its next version. In a chat, call it only after the person said yes or no.

Needs ai:write · changes data

• Canonical address: POST /api/v1/actions/ai.decide_learning

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.learning_decided

What it writes: era_learning (update) — Records the answer; an approval is written to Era’s memory or skills by the table

curl -X POST https://app.getera.io/api/v1/era_learnings/actions/decide_learning \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"id":"ID_ID","decision":"approve"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.learning_decided"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.eraLearnings.decideLearning({
  id: "ID_ID",
  decision: "approve"
})

era era_learnings decide_learning \
  --id "ID_ID" \
  --decision "approve"

{
  "name": "era__ai__decide_learning",
  "arguments": {
    "id": "ID_ID",
    "decision": "approve"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 learning_not_found, already_decided, not_yours, empty_statement, bad_memory_kind, module_required, already_expired, skill_incomplete · 429 slow down

ai.delete_agent

Delete an agent — Removes the agent and its run history. Switching it off is usually what you want.

Needs ai:delete · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.delete_agent

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.agent_deleted

What it writes: ai_agent (delete) — Removes the agent; ai_run (delete) — Its run history goes with it, by cascade

curl -X POST https://app.getera.io/api/v1/ai_agents/AI_AGENT_ID/actions/delete_agent \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.agent_deleted"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiAgents.deleteAgent("AI_AGENT_ID")

era ai_agents delete_agent AI_AGENT_ID

{
  "name": "era__ai__delete_agent",
  "arguments": {
    "id": "AI_AGENT_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:delete · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found · 429 slow down

ai.delete_computer

Delete my cloud computer — Deletes your cloud computer and its disk. This cannot be undone.

Needs ai:handle · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.delete_computer

Input

This action takes no input.

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.computer_machine_requested

What it writes: computer_machine (update) — Asks the worker to delete it; computer_session (update) — Stops tasks running on it

curl -X POST https://app.getera.io/api/v1/computer_machines/actions/delete_computer \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.computer_machine_requested"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.computerMachines.deleteComputer()

era computer_machines delete_computer

{
  "name": "era__ai__delete_computer",
  "arguments": {}
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 no_computer · 429 slow down

ai.delete_conversation

Delete a conversation — Hides a thread. The record changes it made are not undone.

Needs ai:delete · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.delete_conversation

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.conversation_deleted

What it writes: ai_conversation (update) — Writes the tombstone, through sql/056’s door

curl -X POST https://app.getera.io/api/v1/ai_conversations/AI_CONVERSATION_ID/actions/delete_conversation \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.conversation_deleted"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiConversations.deleteConversation("AI_CONVERSATION_ID")

era ai_conversations delete_conversation AI_CONVERSATION_ID

{
  "name": "era__ai__delete_conversation",
  "arguments": {
    "id": "AI_CONVERSATION_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:delete · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found · 429 slow down

ai.delete_task

Delete a task — Removes it from every list.

Needs ai:delete · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.delete_task

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.task_deleted

What it writes: ai_task (update) — Writes the tombstone through sql/082’s door

curl -X POST https://app.getera.io/api/v1/ai_tasks/AI_TASK_ID/actions/delete_task \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.task_deleted"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiTasks.deleteTask("AI_TASK_ID")

era ai_tasks delete_task AI_TASK_ID

{
  "name": "era__ai__delete_task",
  "arguments": {
    "id": "AI_TASK_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:delete · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found · 429 slow down

ai.disconnect_subscription

Disconnect my subscription — Era stops using this plan. The sign-in was revoked at the provider before this runs.

Needs ai:write · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.disconnect_subscription

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.subscription_disconnected

What it writes: ai_provider (delete) — Removes the connection row

curl -X POST https://app.getera.io/api/v1/ai_providers/AI_PROVIDER_ID/actions/disconnect_subscription \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.subscription_disconnected"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiProviders.disconnectSubscription("AI_PROVIDER_ID")

era ai_providers disconnect_subscription AI_PROVIDER_ID

{
  "name": "era__ai__disconnect_subscription",
  "arguments": {
    "id": "AI_PROVIDER_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found, not_owner · 429 slow down

ai.erase_brain_fact

Permanently erase something Era learned — Kalıcı olarak sil: the fact, every earlier and later version of it, its links, the decisions about it and its mention in insights are deleted. Unut only stops Era using it.

Needs ai:manage · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.erase_brain_fact

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.brain_fact_erased

What it writes: brain_erasure (insert) — Records the erasure (without the erased words); brain_fact_review (delete) — Reviews that quote it go with it; decide_decision (delete) — Decisions taken about it go with it; brain_insight (update) — Insights drawn from it lose that source; one with no source left is deleted

curl -X POST https://app.getera.io/api/v1/brain_erasures/actions/erase_brain_fact \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"memoryId":"MEMORY_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.brain_fact_erased"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.brainErasures.eraseBrainFact({
  memoryId: "MEMORY_ID"
})

era brain_erasures erase_brain_fact \
  --memory-id "MEMORY_ID"

{
  "name": "era__ai__erase_brain_fact",
  "arguments": {
    "memoryId": "MEMORY_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 fact_not_found · 429 slow down

ai.erase_brain_person

Erase everything Era learned about a person — A data-subject request (KVKK m.7 / GDPR art. 17): every fact about the person, every version of them, and the person in Era’s memory are deleted; the register keeps that it was done.

Needs ai:manage · removes or cannot be undone · asks a person to confirm when Era runs it

• Canonical address: POST /api/v1/actions/ai.erase_brain_person

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.brain_person_erased

What it writes: brain_erasure (insert) — Records the request and what was erased; brain_fact_review (delete) — Reviews that quote the facts go with them; decide_decision (delete) — Decisions taken about the facts go with them; brain_insight (update) — Insights drawn from the facts lose them; one with no source left is deleted

curl -X POST https://app.getera.io/api/v1/brain_erasures/actions/erase_brain_person \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"entityId":"ENTITY_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.brain_person_erased"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.brainErasures.eraseBrainPerson({
  entityId: "ENTITY_ID"
})

era brain_erasures erase_brain_person \
  --entity-id "ENTITY_ID"

{
  "name": "era__ai__erase_brain_person",
  "arguments": {
    "entityId": "ENTITY_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:manage · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 person_not_found, bad_date · 429 slow down

ai.escalate_approval

Escalate a waiting approval — Tells the approvers a request has waited too long. Machine-only: the approvals list raises it.

Needs ai:read · reads only

Input

Events it publishes: ai.approval_escalated

Errors: 401 no or expired credential · 403 the credential does not hold ai:read · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 429 slow down

ai.evaluate_skill

Record a skill evaluation — Stores how many test cases a version passed. The skill screen runs the cases, then calls this.

Needs ai:write · changes data

• Canonical address: POST /api/v1/actions/ai.evaluate_skill

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.skill_evaluated

What it writes: ai_skill_version (update) — Writes the score

curl -X POST https://app.getera.io/api/v1/ai_skill_versions/AI_SKILL_VERSION_ID/actions/evaluate_skill \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"passed":1,"total":1}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.skill_evaluated"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.aiSkillVersions.evaluateSkill("AI_SKILL_VERSION_ID", {
  passed: 1,
  total: 1
})

era ai_skill_versions evaluate_skill AI_SKILL_VERSION_ID \
  --passed 1 \
  --total 1

{
  "name": "era__ai__evaluate_skill",
  "arguments": {
    "versionId": "AI_SKILL_VERSION_ID",
    "passed": 1,
    "total": 1
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found · 429 slow down

ai.forget_computer_folder

Forget a folder — Era no longer knows this folder by name.

Needs ai:handle · removes or cannot be undone

• Canonical address: POST /api/v1/actions/ai.forget_computer_folder

Input

Preconditions

The action is refused with 409 and one of these codes:

What it writes: computer_folder (delete) — Removes the name

curl -X POST https://app.getera.io/api/v1/computer_folders/COMPUTER_FOLDER_ID/actions/forget_computer_folder \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{}'

{
  "ok": true,
  "result": "…",
  "events": []
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.computerFolders.forgetComputerFolder("COMPUTER_FOLDER_ID")

era computer_folders forget_computer_folder COMPUTER_FOLDER_ID

{
  "name": "era__ai__forget_computer_folder",
  "arguments": {
    "id": "COMPUTER_FOLDER_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:handle · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 not_found · 429 slow down

ai.forget_learning

Forget something ("bunu unut") — Forgets a memory — by its id, or by its words ("bunu unut: Ahmet Bey sabah randevusu"); Era stops using it and it stays in the history — or stops using a skill by its name (paused, not deleted). More than one match is refused with the candidates so you can ask which.

Needs ai:write · removes or cannot be undone

• Canonical address: POST /api/v1/actions/ai.forget_learning

Input

Preconditions

The action is refused with 409 and one of these codes:

Events it publishes: ai.learning_forgotten

What it writes: brain_fact_review (insert) — Records Unut; the table applies it; ai_skill_release (update) — Pauses the skill

curl -X POST https://app.getera.io/api/v1/brain_fact_reviews/actions/forget_learning \
  -H "Authorization: Bearer $ERA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"memoryId":"MEMORY_ID"}'

{
  "ok": true,
  "result": "…",
  "events": [
    "ai.learning_forgotten"
  ]
}

import { createEra } from "@getera/sdk"

const era = createEra({ apiKey: process.env.ERA_API_KEY })
const res = await era.brainFactReviews.forgetLearning({
  memoryId: "MEMORY_ID"
})

era brain_fact_reviews forget_learning \
  --memory-id "MEMORY_ID"

{
  "name": "era__ai__forget_learning",
  "arguments": {
    "memoryId": "MEMORY_ID"
  }
}

Errors: 401 no or expired credential · 403 the credential does not hold ai:write · 404 the record or module is outside what it may reach · 422 invalid input (problems[]) · 409 nothing_to_forget, ambiguous · 429 slow down

ai.link_engine_agent

Link an agent to an assistant — Makes an assistant (persona, skills, integrations) the authoring half of this agent. Empty unlinks.

Needs ai:manage · changes data

• Canonical address: POST /api/v1/actions/ai.link_engine_agent

Input

Preconditions

The action is refused with 409 and one of these codes: