> ## Documentation Index
> Fetch the complete documentation index at: https://docs.slash.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Get agent request

> Get the status and details of an agent request by ID.

Agent requests are created when a read-only API key makes a write request (POST, PUT, PATCH, DELETE) to the Public API. Instead of executing immediately, these requests are deferred and require approval from an authorized user.

Use this endpoint to check the status of a pending request or retrieve the result after execution.




## OpenAPI

````yaml get /agent-request/{agentRequestId}
openapi: 3.1.0
info:
  title: Slash Public API
  description: API description
  version: 0.0.1
  contact: {}
servers:
  - url: https://api.slash.com
    description: production
security:
  - api_key: []
  - partner_api_key: []
  - bearer: []
  - developer_application: []
paths:
  /agent-request/{agentRequestId}:
    parameters:
      - name: agentRequestId
        in: path
        schema:
          type: string
        required: true
        description: >-
          The unique identifier of the agent request (returned in
          x-deferred-action-id header)
    get:
      tags:
        - Agent Requests
      summary: Get agent request
      description: >
        Get the status and details of an agent request by ID.


        Agent requests are created when a read-only API key makes a write
        request (POST, PUT, PATCH, DELETE) to the Public API. Instead of
        executing immediately, these requests are deferred and require approval
        from an authorized user.


        Use this endpoint to check the status of a pending request or retrieve
        the result after execution.
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AgentRequest'
                x-entrypoint:
                  virtualPath: schemas/AgentRequest
                  sourcePath: schemas/AgentRequest.yaml
                  title: AgentRequest
                  origin: ./src/publicApi
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '403':
          description: Forbidden
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '429':
          description: TooManyRequests
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '500':
          description: Internal Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
      security:
        - api_key: []
components:
  schemas:
    AgentRequest:
      type: object
      description: A pending or completed agent request
      properties:
        id:
          type: string
          description: Unique identifier for the agent request
        status:
          type: string
          enum:
            - pending
            - approved
            - rejected
            - expired
            - executed
            - failed
            - running
          description: Current status of the request
        display:
          type: object
          description: Human-readable display information
          properties:
            title:
              type: string
              description: A brief title describing the action
            description:
              type: string
              description: Detailed description of what the action will do
            sections:
              type: array
              description: Key-value details about the request
              items:
                type: object
                properties:
                  label:
                    type: string
                  value:
                    oneOf:
                      - type: string
                      - type: object
                        properties:
                          oldValue:
                            type: string
                          newValue:
                            type: string
                        required:
                          - newValue
                required:
                  - label
                  - value
          required:
            - title
            - sections
        result:
          type: object
          description: >-
            The result of the executed action. Only present when status is
            "executed".
          additionalProperties: true
        createdAt:
          type: string
          format: date-time
          description: When the request was created
      required:
        - id
        - status
        - display
        - createdAt
      x-entrypoint:
        virtualPath: schemas/AgentRequest
        sourcePath: schemas/AgentRequest.yaml
        title: AgentRequest
        origin: ./src/publicApi
      title: AgentRequest
    Error:
      type: object
      properties:
        message:
          type: string
        name:
          type: string
        identifier:
          type: string
        rawStatus:
          type: number
        meta:
          type: object
          additionalProperties: true
      required:
        - message
        - name
        - identifier
        - rawStatus
      x-entrypoint:
        origin: ./src/publicApi
        sourcePath: ./src/publicApi/main.yaml
        title: Error
        virtualPath: components/Error
      title: Error
  securitySchemes:
    api_key:
      type: apiKey
      description: |
        API key authentication for public API requests.

        Keys come in two flavors:

        - *Legal-entity-scoped keys* are pinned to a single legal entity.
          Minted via the dashboard under a specific entity; every request
          acts on that entity.
        - *User-scoped keys* are pinned to a user and span every legal
          entity that user has access to. Every request made with a
          user-scoped key (except `GET /legal-entity`, which lists the
          legal entities the user can access) must include an
          `x-legal-entity` header naming the legal entity the request is
          operating on. Requests without the header are rejected with
          `400`. The authenticated user must have an active permission
          role on the supplied legal entity, otherwise the request is
          rejected with `403`.
      name: X-API-Key
      in: header
    partner_api_key:
      type: apiKey
      description: |
        Partner-program API key authentication.

        Keys are minted in the partner dashboard (Developers → API Keys),
        are scoped to a single partner program, and are prefixed with
        `sk_partner_`. Partner keys are only accepted by routes that
        declare this scheme; they are rejected by `api_key` routes and
        vice versa.
      name: X-API-Key
      in: header
    bearer:
      type: http
      scheme: bearer
    developer_application:
      type: http
      scheme: basic

````