Introducing Igno 1 Arctic

Most conversations with AI start small: a question, a half-formed idea, a document you don't feel like reading, a problem you've been circling for twenty minutes. Then they grow. You add context, change your mind, upload a file, ask it to search, connect another service, turn an answer into a plan and the plan into actual work.

That shift is where a lot of AI systems start to feel less useful. They can answer the next prompt fine, but they lose track of the larger thing you were trying to get done.

Igno 1 Arctic is our first model built specifically to hold onto that thread — not just a general-purpose language model connected to Igno, but one trained around Igno's tools, its long-running tasks, and the way real work actually unfolds across a conversation.

Intelligence that follows the work

There's a particular kind of frustration that comes from an AI that technically remembers what you said but still seems to have lost the point — the facts are there, the intent isn't. Arctic was trained to hold onto both: what you're doing, what's already been decided, what's still open, and what's changed since the conversation began.

In practice, that means you can ask Arctic to explain something unfamiliar, move into researching it, push back on one of its assumptions, hand it a document, change the constraints, and then ask it to produce something from all of that — and it treats those as one continuous piece of work rather than a string of unrelated prompts. We call this thread continuity, and it's one of the things we measured most carefully during development.

Long conversations always accumulate noise — people contradict themselves, priorities shift, new information replaces old. Good context handling isn't just about remembering more tokens; it's about knowing which parts still matter. That's what this score is tracking.

Built for Igno, not placed inside it

Arctic isn't a general model we happened to connect to Igno — it was developed around Igno's actual environment, where conversation, search, tools, long-running work and connected services all sit in the same place.

That means Arctic understands that sometimes the right response is just text, sometimes it should search, sometimes it should check information it already has, sometimes a request should become a longer-running Task, and sometimes it should stop and ask permission before doing something consequential.

It also means knowing when to do less. Agentic systems get annoying fast when they confuse being capable of taking action with needing to take action. Arctic is tuned to tell the difference — a simple question should stay a simple conversation, and only substantial work should pull in the full machinery of planning and tool use.

From answers to outcomes

Most AI interaction still follows prompt → response. Arctic is built around a longer loop: understand → reason → gather → act → verify → continue.

That lets Igno handle requests that would otherwise mean bouncing between separate apps. Say you start with:

Find the problems with our landing page.

Arctic can check available context, pull in Finkkle Search where it needs current information, reason through what it finds, and answer. Then you keep going:

Rewrite the sections that need changing.
Turn that into a proper document.
Compare this against what our competitors are doing.

Arctic treats that as one continuing piece of work, not three separate conversations.

Arctic and Tasks

Some work can't reasonably finish in a single response, which is why Igno has Tasks — room to work through something larger, use tools, generate artifacts, check intermediate results, and keep going until it hits a useful stopping point.

Arctic drives how that unfolds: building a working picture of the goal before acting, identifying constraints, figuring out what's missing, separating what can happen immediately from what needs permission, and tracking intermediate outputs as the task develops. You don't need special syntax for any of it — you describe what you want normally, and Arctic handles the transition into task mode.

Tool use, and recovering when it doesn't go to plan

Giving a model tools is easy. Getting it to use the right one, with the right arguments, at the right moment — and recover when something goes sideways — is much harder. That was a major focus of Arctic's development.

Real work rarely follows the perfect path imagined at the start — a search comes back empty, a connected service behaves differently than expected, a file is missing, an earlier assumption turns out wrong. Arctic is trained to treat these as part of the task rather than the end of it, which is where a meaningful share of the effort behind this release went.

Shield: intelligence needs boundaries

The more capable these systems get, the more restraint matters. That's why Arctic was developed alongside Finkkle Shield, Igno's protection and permission layer. Arctic reasons about what should happen; Shield decides what's actually allowed to happen — and that separation is deliberate.

Low-risk work should feel nearly invisible. Anything involving sensitive information, outside communication, or real consequences should slow down and surface what's about to happen before it happens. Arctic is also trained to be upfront about uncertainty rather than dressing up incomplete evidence as confidence — when something may be outdated, it reaches for Search; when two sources disagree, it says so instead of quietly picking the tidier answer. And when an action goes beyond what Arctic has been given authority for, Shield can stop it even if Arctic knows how to do it.

Search as part of reasoning

Language models know a lot, and they also inevitably contain information that's incomplete, outdated, or missing entirely. Arctic treats retrieval as part of reasoning rather than a separate feature — searching when something depends on recent events, when it needs evidence, or when it hits something unfamiliar, without reaching for search just to look thorough when it already has enough.

A model doesn't become trustworthy simply by knowing more — it becomes trustworthy when it can recognize the edge of what it knows. This is one of the narrower benchmarks in our internal suite, but it's one we treat as a leading indicator for almost everything else.

Plugins and connected services

Igno connects to outside services through Plugins, and Arctic reasons across those connections without making you think about the integrations every time you ask for something. A connected calendar isn't just a calendar tool, a connected inbox isn't just an email tool — they become sources and destinations inside the work itself. You might ask Igno to read an email thread, check it against a document, work out what needs to happen next, and check your calendar for space to respond. You see one request; Arctic coordinates the systems behind it.

Capability profile

Arctic's biggest gains came on tasks where several abilities had to work together — reasoning, memory, search, tool use, planning and judgment, all inside the same request. That's the kind of task real usage is actually made of.

Pacific WorkBench

Our largest evaluation simulates real-world work across research, software, writing, analysis, planning, files and connected tools — deliberately messy, with instructions that change halfway through, irrelevant information mixed in, tools that fail, and cases where the right move is to stop and ask for more information rather than act. A run only counts as successful when the final result satisfies the original objective and every constraint still standing.

Arctic reaches a 68.4% task-success rate on this evaluation, and 52.9% on the hardest multi-stage subset.

Checking its own work

Models often land on an initial interpretation and then spend the rest of their reasoning defending it. Arctic is trained to revisit assumptions when new evidence appears — forming an approach, testing it, catching a contradiction, and switching course. That shows up most in coding, research and analysis work, where the first plausible answer is often not the right one.

The point of reasoning isn't a longer answer — it's one that survives contact with the actual problem.

Faster where speed matters

Arctic is built for substantial, tool-driven work, but a large share of everyday usage is much smaller than that: rewrite this, explain that, summarize this, what does this mean, continue. Arctic is tuned to recognize these cases early and skip unnecessary deeper execution, so lightweight conversational requests stay fast even as the model's underlying reasoning gets more capable.

For complex, tool-driven work, Arctic may intentionally take longer — a slower answer that actually finishes the task is worth more than a fast one that only describes how the task could be done.

How the pieces fit together

Arctic is the model. Igno is the system around it.

Arctic reasons. Finkkle Search gives it access to current information. Tasks give it room to perform larger pieces of work. Plugins connect it to services. Shield defines the boundaries around what's allowed to happen. Projects give the work somewhere to live. None of these alone is Igno — Igno is what happens when they work together.

What we chose not to optimize for

There's pressure in AI development to make every release louder — more parameters, more tokens, more benchmark records, more features. Arctic wasn't built around winning that contest. What we cared about instead: whether the model still understands what you wanted after forty messages, whether it notices a source is outdated, whether it knows an action needs permission, whether it recovers after something fails, and whether it uses tools only when tools are actually needed.

These are less dramatic properties to put on a launch page. They're also the properties that decide whether an AI becomes part of someone's work, or stays something they occasionally ask questions of.

Available in Finkkle Igno

Igno 1 Arctic is rolling out across Finkkle Igno now, powering everything from ordinary conversations to more complex workflows involving Search, Tasks, Plugins and Shield. Not every request needs an agent, not every problem needs deep reasoning, and not every conversation needs to become a project — Arctic is built to tell the difference.

Start with a question. Change direction. Add context. Bring in a file. Search the web. Turn the idea into work. Leave and come back. Ask Igno to continue. The interface stays a conversation — underneath it, considerably more is happening now.

That's Igno 1 Arctic.

Benchmark note

All Arctic benchmark results shown in this article are from Finkkle's internal pre-release evaluation suites. They are intended to measure model performance inside representative Igno workflows and have not been independently audited. Internal scores may change as evaluation sets, model versions and the Igno runtime are updated.