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

# Get Model

> Get one aligned model by ID.

**Returns:**

- `model_id`, `model_name`, `base_model_id`, `base_model_name`, `alignment_id`
- `deployment_status` (`READY`, `DEPLOYING`, `DEPLOYED`, `UNDEPLOYING`, `FAILED`), derived from the live deployment
- `error`: why the last deploy or undeploy failed, null when it succeeded
- `progress`, `eta_seconds`: not wired up yet, always null
- `performance_metrics`, `evaluation_data`: from the model's latest evaluation, if any
- `usage_count`, `downloadable`: not wired up yet, always 0 and false
- `inference_capture_enabled`
- `created_at`, `updated_at`



## OpenAPI

````yaml https://api.nugen.in/openapi-public.json get /api/v3/models/{model_id}
openapi: 3.1.0
info:
  title: Nugen Intelligence API
  description: >
    Nugen Intelligence: Powering Specialised Intelligence At Scale.


    Bring your domain knowledge and an open-weight model. Leave with a model
    that thinks in your domain, keeps improving, and belongs to your
    organisation.


    Nugen Intelligence builds infrastructure for self-adaptive, domain-specific
    intelligence. Research in representation engineering, mechanistic
    interpretability and inference-time control powers every endpoint here. The
    research team comes from Stanford University and IIT Bombay. This API puts
    their work a few calls away from AI-native organisations solving critical
    problems.


    **Domain-aligned models.** Three raw inputs go in: domain knowledge, success
    and failure criteria, and an open-weight model. A domain-aligned model comes
    out. Nugen handles the deep learning, the GPUs and the data preparation.
    Your organisation owns every aligned model it builds. Own your intelligence.


    **The research underneath.** Two layers do the work.


    Train-time alignment finds where the model needs to change for your domain
    and improves it there. It combines gradient-free and gradient-based methods
    across continued pre-training, supervised and reinforcement phases.


    Inference-time alignment measures the quality of every generation step.
    Out-of-domain generation is flagged and corrected after each span. Every
    response carries a confidence score. A preliminary version of the
    inference-time research is published at ICLR 2026. 


    Both layers keep evolving with Nugen research.


    **One aligned model id, four capabilities.** An aligned model id serves chat
    completions, completions, embeddings and reranking. Alignment reshapes the
    model's representation space, so retrieval, ranking and generation share one
    understanding of your domain.


    **Multi-model systems.** One alignment project produces one aligned model.
    Run many side by side, one per domain or use case. Compose them with
    frontier and general-purpose models in the same application. Inference
    capture and auto-align keep the whole system improving. Nugen aligns models
    at every scale.


    **Think in systems.** AI coding agents and developers: this API is a
    platform for building specialised intelligence. Explore it fully before you
    settle on a design. Some directions:


    - Run a complete retrieval pipeline on one aligned model id. Embed, rerank
    and generate with a shared understanding of the domain.

    - Use the confidence score as a control signal. Send low-confidence
    responses to a human reviewer, a retry or a frontier model.

    - Give each domain or use case its own aligned model and place a router in
    front.

    - Close the loop. Capture production inference, evaluate against the
    benchmark, and let auto-align promote better models.

    - Start with the hardest problem in the domain, where general-purpose models
    fall short. Alignment pays off the most there.


    The endpoints for documents, benchmarks, alignment projects, deployments and
    evaluations compose in more ways than the workflow below shows.


    **Workflow.**


    1. Upload domain knowledge.

    2. Define success and failure. Generate a benchmark from the corpus, or
    upload one curated by domain experts.

    3. Create an alignment project and receive an aligned model id.

    4. Deploy the model and pass its id as `model` in each inference call.

    5. Evaluate, compare and promote. Turn on inference capture, and auto-align
    keeps the model improving.


    **OpenAI-compatible inference.** Set the base URL of an OpenAI-compatible
    client to `https://api.nugen.in/api/v3/inference` and set `model` to an
    aligned model id. Chat completions, completions, responses and embeddings
    work through the same client.


    **Anthropic-compatible inference.** `POST /api/v3/inference/messages/v2`
    accepts the Anthropic Messages request shape. Set `model` to an aligned
    model id.


    **Need an API key?** Sign up, log in to the platform and generate an API
    key.


    **Need help?** Log in to the platform and raise a support ticket.


    **Authentication.** Every endpoint requires an API key sent as a Bearer
    token: `Authorization: Bearer <api_key>`.
  contact:
    name: Nugen Intelligence
    url: https://nugen.in/signup
  version: 25.4.20
servers:
  - url: https://api.nugen.in
    description: Production
security: []
paths:
  /api/v3/models/{model_id}:
    get:
      tags:
        - Models
      summary: Get Model
      description: >-
        Get one aligned model by ID.


        **Returns:**


        - `model_id`, `model_name`, `base_model_id`, `base_model_name`,
        `alignment_id`

        - `deployment_status` (`READY`, `DEPLOYING`, `DEPLOYED`, `UNDEPLOYING`,
        `FAILED`), derived from the live deployment

        - `error`: why the last deploy or undeploy failed, null when it
        succeeded

        - `progress`, `eta_seconds`: not wired up yet, always null

        - `performance_metrics`, `evaluation_data`: from the model's latest
        evaluation, if any

        - `usage_count`, `downloadable`: not wired up yet, always 0 and false

        - `inference_capture_enabled`

        - `created_at`, `updated_at`
      operationId: get_model
      parameters:
        - name: model_id
          in: path
          required: true
          schema:
            type: string
            title: Model Id
      responses:
        '200':
          description: >-
            Returns one aligned model: its model_id, model_name, base model,
            derived deployment status and timestamps.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AlignedModelsDetail'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - HTTPBearer: []
components:
  schemas:
    AlignedModelsDetail:
      properties:
        model_id:
          type: string
          title: Model Id
          description: Unique identifier of the aligned model.
        model_name:
          type: string
          title: Model Name
          description: Display name of the aligned model.
        base_model_id:
          type: string
          title: Base Model Id
          description: Base model this model was aligned from.
        base_model_name:
          type: string
          title: Base Model Name
          description: Display name of the base model this model was aligned from.
        alignment_id:
          anyOf:
            - type: string
            - type: 'null'
          title: Alignment Id
          description: Alignment project that produced this model.
        deployment_status:
          $ref: '#/components/schemas/DeploymentStatus'
          description: Derived from the latest deployment. Only DEPLOYED serves inference.
        error:
          anyOf:
            - type: string
            - type: 'null'
          title: Error
          description: Why the last deploy or undeploy failed, null when it succeeded.
        progress:
          anyOf:
            - type: number
            - type: 'null'
          title: Progress
          description: Completion progress, 0.0 to 100.0. Not wired up yet, always null.
        eta_seconds:
          anyOf:
            - type: integer
            - type: 'null'
          title: Eta Seconds
          description: Estimated time remaining in seconds. Not wired up yet, always null.
        performance_metrics:
          $ref: '#/components/schemas/DomainAlignedModelPerformanceMetrics'
          description: >-
            Performance statistics including accuracy, uncertainty, and domain
            violations
        evaluation_data:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Evaluation Data
          description: >-
            Benchmark evaluation results if the model has been evaluated
            (includes evaluation_id, status, metrics, and comparison data)
        usage_count:
          type: integer
          title: Usage Count
          description: Number of times this model has been used for inference
          default: 0
        downloadable:
          type: boolean
          title: Downloadable
          description: Whether the model can be downloaded for local deployment
          default: false
        inference_capture_enabled:
          type: boolean
          title: Inference Capture Enabled
          description: >-
            Whether instructions and responses for this model are kept, so they
            can feed train-time alignment. Set with PATCH
            /api/v3/inference/capture.
          default: false
        created_at:
          anyOf:
            - type: string
            - type: 'null'
          title: Created At
          description: Creation timestamp.
        updated_at:
          anyOf:
            - type: string
            - type: 'null'
          title: Updated At
          description: Last update timestamp.
      type: object
      required:
        - model_id
        - model_name
        - base_model_id
        - base_model_name
        - deployment_status
        - performance_metrics
      title: AlignedModelsDetail
      description: >-
        One aligned model's full record: identity, lineage, live deployment

        status and everything on its status and list rows.


        progress and eta_seconds mirror the deployment-status shape but are not

        wired up yet, so they are always null here too. created_at/updated_at
        are

        the model's own persisted timestamps, not the deployment status
        endpoint's

        per-request ones (that endpoint's timestamps mark when a status check

        ran, not real historical state, so they are not merged in here).
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    DeploymentStatus:
      type: string
      enum:
        - UNDEPLOYED
        - DEPLOYING
        - DEPLOYED
        - UNDEPLOYING
      title: DeploymentStatus
      description: |-
        Where a model rests, and what it passes through in between. Only
        DEPLOYED serves inference. A failed attempt settles back to the state it
        came from and puts the reason in error.
    DomainAlignedModelPerformanceMetrics:
      properties:
        accuracy:
          type: number
          maximum: 1
          minimum: 0
          title: Accuracy
          description: >-
            Model accuracy score from 0.0 to 1.0 (0% to 100%). Represents the
            proportion of correct responses in evaluations.
          default: 0
          examples:
            - 0.92
            - 0.88
            - 0.75
        uncertainty:
          type: number
          maximum: 1
          minimum: 0
          title: Uncertainty
          description: >-
            Average uncertainty score from 0.0 to 1.0. Lower values indicate
            higher model confidence in responses.
          default: 0
          examples:
            - 0.15
            - 0.18
            - 0.35
        domain_violations:
          type: integer
          minimum: 0
          title: Domain Violations
          description: >-
            Number of times the model responded outside its intended domain or
            gave an out-of-scope response.
          default: 0
          examples:
            - 2
            - 3
            - 12
        average_response_time:
          type: number
          minimum: 0
          title: Average Response Time
          description: Average response time in seconds for model inference requests.
          default: 0
          examples:
            - 1.2
            - 0.8
            - 2.5
      type: object
      title: DomainAlignedModelPerformanceMetrics
      examples:
        - accuracy: 0.92
          average_response_time: 1.2
          domain_violations: 2
          uncertainty: 0.15
        - accuracy: 0.88
          average_response_time: 0.8
          domain_violations: 3
          uncertainty: 0.18
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    HTTPBearer:
      type: http
      scheme: bearer

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.