## Create a new memory entry

`client.MemoryLayers.Entries.New(ctx, memoryLayerID, body) (*MemoryEntryDetail, error)`

**post** `/v1/memory_layers/{memoryLayerId}/entries`

Creates a new entry in a memory layer. Returns the detail view, including the resolved content body.

### Parameters

- `memoryLayerID string`

- `body MemoryLayerEntryNewParams`

  - `Metadata param.Field[CreateResourceMetadata]`

    CreateResourceMetadata contains the user-provided fields for creating
    a workspace-scoped resource. Read-only fields (id, account_id, workspace_id, profile_id,
    created_at) are excluded since they are set by the server.

  - `Spec param.Field[MemoryEntryCreateSpec]`

    MemoryEntryCreateSpec is the input shape for CreateMemoryEntry. It accepts
    either inline content or a reference to a completed Upload; exactly one of
    the two must be set.

### Returns

- `type MemoryEntryDetail struct{…}`

  MemoryEntryDetail is the full representation of an entry, including the
  resolved content body. Returned by GetMemoryEntry, CreateMemoryEntry, and
  UpdateMemoryEntry.

  - `Content string`

    The resolved body of the entry. For entries created or updated via an
    upload_id, this is the ingested content, not the original upload handle.
    May be empty; an entry with only a key, title, and description is valid
    (e.g., a stub skill being drafted, or an entry where the frontmatter
    alone is the payload).

  - `Metadata ResourceMetadata`

    Standard metadata for persistent, named resources (e.g., agents, tools, prompts)

    - `ID string`

      Unique identifier for the resource (prefixed ULID, e.g., "agent_01HXK...")

    - `AccountID string`

      Account this resource belongs to for multi-tenant isolation (prefixed ULID)

    - `CreatedAt Time`

      Timestamp when this resource was created

    - `Name string`

      Human-readable name for the resource (e.g., "Customer Support Agent", "Email Tool")
      Required for resources that users interact with directly

    - `ProfileID string`

      ID of the actor (user or service account) that created this resource

    - `WorkspaceID string`

      Workspace this resource belongs to for organizational grouping (prefixed ULID)

    - `ExternalID string`

      External ID for the resource (e.g., a workflow ID from an external system)

    - `Labels map[string, string]`

      Arbitrary key-value pairs for categorization and filtering
      Examples: {"environment": "production", "team": "platform", "version": "v2"}

  - `Spec MemoryEntrySpec`

    MemoryEntrySpec is the metadata portion of an entry — the fields that
    identify and describe it, without the body. It appears on both the summary
    (MemoryEntry) and detail (MemoryEntryDetail) views.

    - `Key string`

      The lookup key for this entry within its layer. Must conform to the S3
      object key safe-characters spec: ASCII alphanumerics and the special
      characters !, -, _, ., *, ', (, ), and /. Forward slashes may be used to
      suggest hierarchy (e.g., "skills/postmortem/write"), but lookups are flat
      — the key is a single opaque string, not a path.

      Additional rules enforced by the service:

      - May not begin or end with /
      - May not contain consecutive slashes (//)
      - May not begin with reserved prefixes (cadenya/, system/)
      - Case-sensitive
      - Unique within the parent layer

      For skills entries, this key is also the id the model passes to
      memory_load_skill when it decides to load the entry's content.

    - `Description string`

      One-line "when to use this" hint shown in the frontmatter manifest for
      skills entries. The model uses this to decide whether to load the body,
      so it should be written for the model as the audience. Ignored for layer
      types that do not advertise frontmatter.

    - `Title string`

      Short human/LLM-readable title shown in the frontmatter manifest for
      skills entries. Ignored for layer types that do not advertise frontmatter.

  - `Info MemoryEntryInfo`

    - `CreatedBy Profile`

      Profile represents a human user at the account level.
      Profiles are account-scoped resources that can be associated with multiple workspaces
      through the Actor model. Authentication for profiles is handled via SSO/OAuth (WorkOS).

      - `Metadata AccountResourceMetadata`

        AccountResourceMetadata is used to represent a resource that is associated to an account but not to a workspace.

        - `ID string`

          Unique identifier for the resource (prefixed ULID, e.g., "apikey_01HXK...")

        - `AccountID string`

          Account this resource belongs to for multi-tenant isolation (prefixed ULID)

        - `Name string`

          Human-readable name for the resource (e.g., "Customer Support Agent", "Email Tool")
          Required for resources that users interact with directly

        - `ProfileID string`

        - `ExternalID string`

          External ID for the resource (e.g., a workflow ID from an external system)

        - `Labels map[string, string]`

          Arbitrary key-value pairs for categorization and filtering
          Examples: {"environment": "production", "team": "platform", "version": "v2"}

      - `Spec ProfileSpec`

        ProfileSpec contains the profile-specific fields

        - `Type ProfileSpecType`

          Type is the type of profile. User's are humans, API keys are computers. You know the deal.

          - `const ProfileSpecTypeProfileTypeUser ProfileSpecType = "PROFILE_TYPE_USER"`

          - `const ProfileSpecTypeProfileTypeAPIKey ProfileSpecType = "PROFILE_TYPE_API_KEY"`

          - `const ProfileSpecTypeProfileTypeSystem ProfileSpecType = "PROFILE_TYPE_SYSTEM"`

        - `Email string`

          Email address of the user (required, unique per account)

        - `Name string`

          Display name for the user (e.g., "Bobby Tables")

    - `MemoryLayer ResourceMetadata`

      Standard metadata for persistent, named resources (e.g., agents, tools, prompts)

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cadenya/cadenya-go"
  "github.com/cadenya/cadenya-go/option"
  "github.com/cadenya/cadenya-go/shared"
)

func main() {
  client := cadenya.NewClient(
    option.WithAPIKey("My API Key"),
  )
  memoryEntryDetail, err := client.MemoryLayers.Entries.New(
    context.TODO(),
    "memoryLayerId",
    cadenya.MemoryLayerEntryNewParams{
      Metadata: cadenya.F(shared.CreateResourceMetadataParam{
        Name: cadenya.F("name"),
      }),
      Spec: cadenya.F(cadenya.MemoryEntryCreateSpecParam{
        Key: cadenya.F("key"),
      }),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", memoryEntryDetail.Content)
}
```

#### Response

```json
{
  "content": "content",
  "metadata": {
    "id": "id",
    "accountId": "accountId",
    "createdAt": "2019-12-27T18:11:19.117Z",
    "name": "name",
    "profileId": "profileId",
    "workspaceId": "workspaceId",
    "externalId": "externalId",
    "labels": {
      "foo": "string"
    }
  },
  "spec": {
    "key": "key",
    "description": "description",
    "title": "title"
  },
  "info": {
    "createdBy": {
      "metadata": {
        "id": "id",
        "accountId": "accountId",
        "name": "name",
        "profileId": "profileId",
        "externalId": "externalId",
        "labels": {
          "foo": "string"
        }
      },
      "spec": {
        "type": "PROFILE_TYPE_USER",
        "email": "email",
        "name": "name"
      }
    },
    "memoryLayer": {
      "id": "id",
      "accountId": "accountId",
      "createdAt": "2019-12-27T18:11:19.117Z",
      "name": "name",
      "profileId": "profileId",
      "workspaceId": "workspaceId",
      "externalId": "externalId",
      "labels": {
        "foo": "string"
      }
    }
  }
}
```