Agnes 3.0 Flash

Agnes 3.0 Flash is Agnes AI's next-generation text model for agentic coding and tool-driven tasks, with stronger end-to-end execution quality.

Model

agnes-3.0-flash

API endpoints

Chat Completions: POST /v1/chat/completions
Responses: POST /v1/responses
Messages: POST /v1/messages

Model type

New-generation text model with text and image-URL input.

Core focus

Focused on stable execution, reliable tool use, long-task context retention, and high-quality delivery.

Overview

Designed for real-world agent tasks and development workflows, covering the full execution path from task understanding and planning to tool use and final delivery. Focuses on stability, instruction following, grounded execution, and output integrity in complex tasks.

API information

Item	Value
Base URL	`https://apihub.agnes-ai.com/v1`
Chat Completions	`POST /v1/chat/completions`
Responses API	`POST /v1/responses`
Messages API	`POST /v1/messages`
Model name	`agnes-3.0-flash`
Input modalities	Text and image URL
Output modality	Text
Context window	`512K`
Maximum output	`65,536 tokens`

Core directions

Agnes Code task execution

Better suited to Agnes Code and coding-agent workflows, strengthening execution from requirements understanding through final delivery.

Tool calling and orchestration

Stronger function calling, tool selection, and multi-step tool orchestration for more stable agent execution.

Instruction and context adherence

Maintains objectives, constraints, and runtime context throughout long-running and multi-turn tasks.

Trustworthy delivery

Strengthens factual grounding, result verification, and output integrity while reducing unsupported conclusions and incorrect completion claims.

Capability highlights

More reliable end-to-end delivery — improved task planning, execution, and result verification help complex agent tasks reach genuine completion.
More stable tool orchestration — interprets tool definitions, selects appropriate tools, and coordinates multi-step calls more reliably.
Stronger instruction and context adherence — long-running and multi-turn tasks stay aligned with the original objective and constraints.
More trustworthy execution results — greater attention to tool results and factual grounding reduces unsupported conclusions.
Cleaner, more complete output — reduced repetition and malformed text produce clearer, more coherent responses.

Chat Completions API

Endpoint and headers

POST https://apihub.agnes-ai.com/v1/chat/completions

-H "Authorization: Bearer YOUR_API_KEY"
-H "Content-Type: application/json"

Request fields

Field	Type	Required	Description
`model`	string	Yes	Use `agnes-3.0-flash`.
`messages`	array	Yes	Conversation messages with `system`, `user`, and `assistant` roles.
`messages[].content`	string / array	Yes	Plain text or content blocks containing `text` and `image_url`.
`temperature`	number	No	Controls output randomness.
`top_p`	number	No	Controls nucleus sampling.
`max_tokens`	integer	No	Maximum number of output tokens.
`stream`	boolean	No	Returns a streamed response when `true`.
`tools`	array	No	Tool definitions for function-calling workflows.
`tool_choice`	string / object	No	Controls whether and how the model calls tools.
`chat_template_kwargs`	object	No	Extension field for Thinking and other compatible features.

Image URL input

Pass public image URLs together with text in messages[].content.

Basic request

curl https://apihub.agnes-ai.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "agnes-3.0-flash",
    "messages": [
      {
        "role": "user",
        "content": "Explain how an agent should choose and call a tool."
      }
    ],
    "max_tokens": 1024
  }'

Response format

Chat Completions responses use an OpenAI-compatible structure. Read generated text from choices[].message.content. For a tool call, inspect choices[].message.tool_calls, execute the requested function, append its result to messages, and submit the next Chat Completions request.

Responses API

Accepts text or structured messages through input.

POST https://apihub.agnes-ai.com/v1/responses

Field	Type	Required	Description
`model`	string	Yes	Use `agnes-3.0-flash`.
`input`	string / array	Yes	Plain-text prompt or structured input messages.
`max_output_tokens`	integer	No	Maximum output budget.

Read generated text from a message item in output where output[].type is message and output[].content[].type is output_text.

Messages API

Anthropic-compatible Messages API.

POST https://apihub.agnes-ai.com/v1/messages

Field	Type	Required	Description
`model`	string	Yes	Use `agnes-3.0-flash`.
`max_tokens`	integer	Yes	Maximum output-token budget.
`messages`	array	Yes	Messages with `user` and `assistant` roles.
`messages[].content`	string / array	Yes	Plain text or Anthropic-compatible content blocks.
`system`	string / array	No	System instruction.
`temperature`	number	No	Controls output randomness.
`stream`	boolean	No	Returns a streamed response when `true`.

Read generated text from content[] items where content[].type is text.

Thinking mode

Enable Thinking mode when your integration needs more deliberate task decomposition or reasoning. OpenAI-compatible and Anthropic-compatible formats are supported.

Best practices

Agnes Code and agent tasks — state the task objective, repository or runtime context, constraints, expected output, and tool permissions. Return tool results to the conversation before asking the model for the next action.
Tool calling — write narrow tool descriptions and JSON schemas. Validate tool arguments in your application before executing side-effecting actions.
Long-running tasks — break complex work into verifiable stages, and preserve the objective, constraints, and key tool results across each execution round.

Limits and pricing

Item	Value
Context window	`512K`
Maximum output	`65,536 tokens`

Billing item	List price	Current price
Cached input	`$0.005 / 1M tokens`	`$0 / 1M tokens`
Input tokens	`$0.05 / 1M tokens`	`$0 / 1M tokens`
Output tokens	`$0.15 / 1M tokens`	`$0 / 1M tokens`