Introducing Igno 1 Pacific

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's usually where AI systems start to lose the thread. They can answer the next prompt fine, but they lose sight of what you were actually trying to accomplish.

Igno 1 Pacific is our attempt to fix that.

Pacific is the newest model behind Finkkle Igno, built on what we learned from our Arctic research line but aimed at a different question. Not how intelligent can we make a model, but how useful can that intelligence stay as the work around it keeps changing.

Pacific is built for conversations that don't stay conversations — research that turns into writing, writing that turns into a presentation, a question that needs a search, an idea that eventually needs another person, another service, or another device.

Intelligence that follows the work

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

In practice that means you can ask Pacific 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 piece of work rather than a string of unrelated prompts. We call this thread continuity, and it's one of the things we spent the most time measuring.

What matters here isn't that Pacific starts higher — it's that it degrades more slowly. Long conversations always accumulate noise; people contradict themselves, priorities shift, new information replaces old. Handling that well isn't about remembering more tokens, it's about knowing which parts still matter. That's where Pacific is meaningfully better.

Built for Igno, not bolted onto it

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

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

And sometimes the right move is to do less. Agentic systems get annoying fast when they confuse being capable of taking action with needing to take action. Pacific has been tuned to tell the difference — a simple question stays a simple conversation, and substantial work gets the machinery it actually needs. That's a big part of why Pacific feels calmer than what came before it: it's not trying to prove it's an agent, it's trying to figure out what the work requires.

From answers to outcomes

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

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

Find the problems with our landing page.

Pacific 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.
Make the changes into a Task and finish the full audit.

Pacific treats that as one continuing piece of work, not five separate conversations — which is the whole point.

Pacific 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.

Pacific drives how that unfolds. Before acting, it builds a working picture of the goal, identifies constraints, figures out what's missing, separates what can happen immediately from what needs permission, tracks intermediate outputs, and can revise the plan mid-task without losing the original objective.

The result sits somewhere between a rigid automation and an ordinary chat. And you shouldn't need special syntax to get there — you describe what you want normally, and Pacific handles the transition into task mode itself.

Better tool use

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 for Pacific.

The biggest jump wasn't tool selection — it was recovery. Real work rarely goes according to plan: a search comes back empty, a connected service behaves differently than expected, a file is missing, a page has changed, an earlier assumption turns out wrong. Pacific treats those as part of the task rather than the end of it, which matters a lot once Igno is doing more than generating text.

Relay: when the work involves other people

Some tasks eventually need something from outside your workspace — information from someone, an approval, coordination with a service. That's what Finkkle Relay handles.

Pacific provides the reasoning: understanding why communication is needed, what actually has to be shared, what should stay private, and where approval is required before moving forward. The goal isn't an AI that starts messaging everyone on its own — it's closer to the opposite. Pacific needs to know the difference between I can do this and I have permission to do this, and Relay is what lets work cross that line deliberately. A Task can reach a point where it needs a reply from a teammate; Pacific prepares the next step, Relay handles the communication, and once a response comes back, Pacific picks the thread back up. From your side, it's still one piece of work.

Shield: intelligence needs boundaries

The more capable these systems get, the more restraint matters. That's why Pacific was developed alongside Finkkle Shield, Igno's protection and permission layer. Pacific 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, devices, or real consequences should slow down and surface what's about to happen before it happens.

Pacific is also trained to be more honest about uncertainty — not to dress up incomplete evidence as confidence just because confident language reads better. 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 Pacific has been given authority for, Shield can stop it even if Pacific knows how to do it. Capability without boundaries isn't autonomy — it's just unpredictability.

Search as part of reasoning, not separate from it

Language models know a lot, and they also inevitably contain information that's incomplete, outdated, or missing entirely. Pacific treats retrieval as part of reasoning rather than a bolted-on feature: it searches when something depends on recent events, when it needs evidence, or when it hits something unfamiliar — and it doesn't search just to look thorough when it already has enough. The goal isn't “AI plus search,” it's a system that knows when an answer should come from the model versus from the world.

Knowing when it doesn't know

We run an internal test called Grounding Judgment: a mix of questions, some answerable from stable knowledge, some dependent on recent information, some built on false assumptions, some needing evidence, some about obscure entities the model shouldn't be confident about. The model is scored on whether it picks the right information strategy before answering.

It sounds like a narrow benchmark, but it's one we care about most — a model doesn't become trustworthy by knowing more, it becomes trustworthy by recognizing the edge of what it knows.

Plugins become part of the conversation

Igno connects to outside services through Plugins, and Pacific reasons across those connections without making you think about integrations every time. A connected calendar isn't just a calendar tool, a connected inbox isn't just an email tool — they're sources and destinations inside the work itself. You might ask Igno to read an email thread, check it against a document, figure out what needs to happen next, check your calendar, and draft a reply. You see one request; Pacific coordinates several systems behind it. That's the level at which we want Plugins to disappear into Igno.

One model across your devices

Remote extends the same idea to hardware. Igno is being built to work with supported computers, phones and other connected devices when you explicitly allow it. A command like “open the report on my computer” is simple, but the model behind it needs to understand that the work is the constant and the device is just where one part of it happens — whether that's finishing a Task from your phone and placing the output somewhere useful, or spanning a browser, a local machine, and a connected service in one workflow.

Remote doesn't make every device magically controllable — individual platforms still have their own APIs and limits — but Pacific gives Igno a shared reasoning layer across whatever's actually available.

A model that can change pace

Users don't always want maximum reasoning. Sometimes it's a hard technical question, sometimes you just want a paragraph renamed, and treating both the same makes an AI feel slow and mechanical. Pacific adjusts how much internal work it does based on the task — simple conversations stay fast, ambiguous problems get more reasoning, multi-tool tasks get planned differently from questions that need none of that. When something genuinely needs extended execution, Igno moves into its task environment on its own. You don't pick a reasoning mode or configure anything — you ask for what you need, and Pacific figures out the right depth.

The Pacific evaluations

Exam-style benchmarks are useful, but they don't tell you whether a model can hold six constraints through a 25-step research task, call the right service, and catch that its final answer contradicts something it found ten minutes earlier. So Pacific's internal suite is built around actual work.

The biggest gains over Arctic came on tasks where several abilities had to work together — which matters more to us than isolated improvements, since a real request rarely tests just one skill at a time.

Pacific WorkBench

Our largest evaluation, Pacific WorkBench, simulates real-world work across research, software, writing, analysis, planning, files and connected tools — deliberately messy, with instructions that change mid-task, irrelevant information, tools that fail, and tasks that require stopping rather than acting. A run only counts as successful if the final result satisfies the original goal and every constraint still standing.

Pacific reaches a 91.7% task-success rate on the pre-release WorkBench set, versus 68.4% for Arctic. On the hardest multi-stage subset, it's 84.6% versus 52.9%. The gap isn't about better sentences — Pacific just loses the task less often.

Long context, without pretending everything matters equally

Pacific supports a large working context, but context size alone doesn't describe useful memory — a model can take in a huge amount of information and still not know what to do with it. So we focused on retrieval within the context, not just its size.

Pacific tracks relationships between user instructions, decisions already made, temporary assumptions, files and artifacts, tool results, open questions, constraints, and the current objective — and older information doesn't automatically outweigh newer instructions. If you tell Pacific early on that you want a ten-page report and later ask for a two-page summary instead, it shouldn't cling to the first instruction. Memory only helps when it comes with judgment about what to keep weighting.

Better writing, without one house voice

As models get more polished, everything they write starts sounding like the same person wrote it. Pacific has been tuned to follow your voice instead: short requests stay short, technical writing stays technical, a founder update doesn't read like a school essay, a personal message doesn't sprout a heading and three bullet lists. It still has a personality — it's just quieter, so the work stays yours.

More deliberate reasoning

Pacific is also better at changing its mind. Models often land on an initial interpretation and then spend the rest of their reasoning defending it; Pacific is trained to revisit assumptions when new evidence shows up, form an approach, test it, catch a contradiction, and switch course. That shows up most in coding, research, and analysis work, where the first plausible answer is often the wrong one.

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

Faster where speed matters

Pacific is more capable than Arctic, but not every interaction needed to get heavier. Most of Igno's usage is small: rewrite this, explain that, summarize this, continue. Pacific recognizes many of these cases early and skips unnecessary deeper execution, which has cut median time-to-first-response by roughly 31% on lightweight conversational requests compared with our previous Arctic configuration.

For complex, tool-driven work, Pacific may intentionally take longer — and we're fine with that. A slower answer that actually finishes beats a fast one that just describes how the task could be done.

Pacific is not Igno

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

Pacific reasons. Finkkle Search gives it current information. Tasks give it room for larger work. Plugins connect it to services. Remote extends supported actions to devices. Relay helps it coordinate beyond the conversation. Shield defines 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 didn't optimize for

There's constant pressure to make every release louder — more parameters, more tokens, more benchmark records, more visible reasoning. We didn't build Pacific around winning that contest. What we actually care about: whether the model still understands what you wanted forty messages in, whether it notices a source is outdated, whether it knows an action needs permission, whether it recovers after something fails, whether it uses five tools when five are needed and none when none are. Those are quieter properties, but they're what determines whether an AI becomes part of someone's work or stays something they occasionally poke at.

From Arctic to Pacific

Pacific wouldn't exist without Arctic. Arctic taught us where execution breaks, where models lose arguments, where fluent answers hide incomplete work, where long conversations drift from their original goal, and where a model should hand a decision to something like Shield instead of trying to reason through every boundary itself. Pacific takes those lessons and turns them into something considerably more complete — Arctic was about surviving difficult conditions; Pacific is about moving through them.

The beginning of the Igno model family

Pacific is Igno 1 — a foundation, not a finished destination we'll just swap out for something bigger next year. Future Igno models will push further into reasoning, multimodal understanding, device interaction, long-running execution and collaboration. Some will be larger, some smaller, some specialized. What they'll share is the idea that intelligence should understand not just the question in front of it, but the work around that question.

Available in Finkkle Igno

Igno 1 Pacific is rolling out across Finkkle Igno now, powering everything from ordinary conversations to complex workflows across Search, Tasks, Plugins, Relay and Remote. Not every request needs an agent, not every problem needs deep reasoning, and not every conversation needs to become a project — Pacific 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, a lot more is happening now.

That's Igno 1 Pacific: a calmer way to think with AI, and a more capable way to finish what you started.

Benchmark note

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