An Agent Endpoint With Four Inputs and a JSON Contract

Through OrcaRouter the OrcaCyber MiMo Flash API is an agent endpoint before it is anything else: tools, JSON output, four input modalities, and a million-token window at $0.80 in and $1.60 out per million [OURS]. That combination defines a specific architecture — intake, reason, emit — and the card is cheap enough at these rates to run that architecture at volume.

Here is what the architecture looks like when it is built on this endpoint.

Intake: four paths into one request

The intake block takes whatever the incident produced. Text, images, audio and video all enter the same message array as typed parts [OURS].

The design decision is what to convert before sending. Three rules that hold up:

Do not transcribe what the model can hear. Transcribing first loses the information that made audio worth sending.

Do convert what is already text. A PDF rendering of a log is worse than the log.

Segment media. Minutes of audio, clips of video, single screenshots. Segmenting reduces tokens and increases signal at the same time.

Intake is also where you enforce privacy: the shortest clip containing the evidence is both cheaper and more defensible than a full recording.

Reason: the tool loop

Function calling is native — define the tools, the model emits calls [OURS]. For a security agent the useful tools are few: a search across the evidence set, a lookup against an inventory, a sandbox command, a write to the findings store.

Two constraints shape the loop.

The context window is shared. Every tool result enters the context, and a million tokens goes quickly when logs and media are in play. Compaction is not optional at scale.

The output ceiling applies per call. 131,072 tokens per response is generous for a step and insufficient for a full report; the report belongs in a separate call with a separate budget.

Emit: the JSON contract

The card supports structured output with a schema, and this is the part that makes the pipeline maintainable.

A finding that arrives as prose has to be parsed, and parsing prose is where downstream systems acquire their fragility. A finding that arrives as a validated object either fits the schema or fails loudly. The second behaviour is far easier to operate.

Design the schema before the prompt. Fields decide what the model attends to, and a well-chosen field list is a better instruction than three paragraphs of guidance.

The failure modes to instrument

An agent endpoint fails in four ways worth logging separately.

Tool errors. A call that returns an error and is retried is a different event from one that is not retried.

Plan drift. The agent completes calls but drifts from the objective. This is the most common failure and the least visible: the transcript looks fine.

Truncation. A response that hits the 131,072 ceiling and stops. Always check the finish reason.

Schema violations. An output that does not validate. Cheap to detect, and rare when the schema is well designed.

Four counters, logged per run, turn a black box into something you can operate.

What this architecture costs

A single agent run over one incident: 300,000 input tokens across the initial request and two tool round-trips, 15,000 output tokens.

0.3 × $0.80 + 0.015 × $1.60 = $0.264 per run [OURS].

A hundred runs a day is $26.40. That is the number to hold in mind when deciding how thorough to make the intake: doubling the evidence from 150,000 to 300,000 tokens adds thirteen cents per run, which is usually worth paying.

Where the architecture has to change

Two conditions break the simple three-stage design.

When the artifact must be long. The 131,072 ceiling forces a separate write-up call, on this card or another.

When the evidence is huge. A million tokens sounds like a lot until media is involved; a request carrying a repository, logs and a recording can exceed it.

Both are design problems, not model problems, and both are cheaper to solve before the pipeline exists.

Observability is part of the architecture

An agent that cannot be inspected cannot be operated. Four fields per run make the difference.

Turn count. A run that takes twelve turns where three were expected is drifting, and the count is the cheapest signal you will get.

Tokens per turn. A flat profile means steady work; a rising one means tool output is accumulating without compaction.

Tool failure rate. Errors per tool, per run. A tool that fails a third of the time is the real cause of most stalled agents, and it is invisible if you only log final outcomes.

Finish reason. Every response, every turn. Truncation and completion look identical in the text.

None of these requires a tracing vendor. Four columns in a table is enough, and at twenty-six cents a run you can afford to keep the table for a long time.

The first week of a new agent

Three things to do before you trust it with real evidence.

Run it on a case you already solved. You know the answer, so you can judge the reasoning rather than the prose.

Run it twice on the same case. Agents are stochastic; two runs tell you how much variance you are buying.

Run it on a case you cannot solve. That is the one that reveals whether it adds anything, and it is the one people skip because the result is hard to grade.

A week of this produces a mental model of the agent’s strengths that no specification provides, and it costs a few dollars.

The takeaway

Intake, reason, emit: four modalities in, tools in the middle, validated JSON out, at about twenty-six cents per incident run. The shape is simple enough to describe in a sentence, which is a good sign for an architecture you will have to operate.

The two things that need designing up front are compaction and the write-up call. Everything else is configuration.

And configuration is worth keeping in one place. An agent whose tool list, schema and stop conditions live in a single file can be reviewed by someone who did not build it — which is the difference between an internal tool and a black box.

One last design note: keep the model string and the tool list in the same configuration file. When either changes, the other usually needs revisiting, and a pipeline where those two facts live in different places is one where half a change ships.

Sourcing note: capabilities, modalities, pricing, context window and the access gate are from the OrcaRouter model page, checked 2026-10-27 [OURS]. Per-run costs are arithmetic on those rates at the stated token counts. No latency, reliability or benchmark figures are used, because the card’s production sample is one day old [OURS].