Native Chat is Influxx's chat interface for AI coding agents — bubbles, a composer, diffs, cards for approvals — and it looks, at a glance, like a direct line into whatever agent you're running. It isn't, not yet: underneath the bubbles, Native Chat is a layer built on top of your terminal, typing into the exact same session you'd type into yourself and reading back whatever scrolls past. That's either a clever shortcut or an honest admission of a limitation, depending on how plainly you describe it. We'd rather describe it plainly, because that same honesty is what led us to remove a set of controls that looked more capable than the architecture underneath them could actually support.
What You Get When You Open Native Chat
Native Chat exists because a raw terminal is a great interface for issuing a command and a mediocre one for following a conversation. Scrollback erases context, a long tool call buries the question sitting underneath it, and a proposed code change reads as a wall of plus and minus signs unless you already read that format fluently. Native Chat sits on top of the same agent session and gives it a shape suited to conversation instead of scrollback:
- A composer, not a blinking cursor: a persistent text box for writing to the agent, instead of a prompt at the bottom of a pane that's scrolled three screens past what you last read.
- A real diff view: changes the agent proposes render as an actual diff, additions and deletions laid out for a human to scan, instead of a stream of markup mixed in with everything else the agent printed.
- Cards for tool runs and approvals: when the agent runs a command or stops to ask permission for something, that moment becomes its own card in the conversation, not a paragraph you have to notice among everything scrolling past it.
- Autocomplete for skills: start typing the name of a skill you want the agent to invoke, and Native Chat completes it, instead of asking you to remember and retype the exact phrase yourself.
- Paste an image straight in: drop a screenshot into the composer the way you would in any chat app, and it goes to the agent as part of the conversation.
None of that is exotic by the standards of chat products generally. What's worth explaining honestly is what's actually running underneath it, because it isn't what most people assume.
A Chat Interface for AI Coding Agents That Lives Inside a Terminal
Here's the part we'd rather say plainly than gloss over: Native Chat does not talk to your coding agent through some dedicated, structured channel built for the purpose. It talks to the same hosted terminal session you'd be looking at if you closed the chat view and opened the raw pane instead. When you type into the composer and hit send, Native Chat injects that text into the running terminal exactly as if you had typed it yourself and pressed the same key. When the agent responds, Native Chat isn't receiving a tidy structured reply — it's parsing the terminal's output, plus whatever hook events that particular agent CLI happens to emit, and turning that parsed stream into the bubbles, diffs, and cards you actually see.
Why Build the Skin First
That's a deliberate order of operations, not a corner we cut. Every agent CLI Influxx supports already has a terminal interface, because a terminal interface is the one thing every one of them is guaranteed to expose. Building Native Chat as a layer on that shared surface meant we could ship a friendlier conversational interface for all of them at once, on day one, instead of waiting for each vendor to publish a deeper integration point and then building thirty separate deep integrations before any of them shipped. A skin over an existing terminal is the fast, pragmatic way to make an agent's session legible to a human being, right now, for every CLI Influxx runs.
"People assume Native Chat has some backstage line into the agent's own process. For most agents, today, it doesn't. It's watching the same terminal a person would watch, typing into it the same way a person would type, and rendering what comes back. That's a real engineering choice with a real cost, and we'd rather be specific about where that cost shows up than let anyone assume we've built something we haven't."
— Daniel Kwon, Staff Engineer, Agent Orchestration at ETAPX
What a Terminal Layer Can't Do Yet
Because Native Chat is a layer on top of a terminal session rather than a first-class client speaking the agent's own protocol, there's a specific, honest boundary to what it can do. It cannot reach in and directly set which model the agent is using. It cannot directly set the agent's reasoning-effort level. It cannot directly set the agent's permission mode, and it cannot reach into other structured, session-lifecycle state the way a purpose-built client eventually could. What it can do is type a command into the terminal the agent happens to be running in, and then watch what comes back afterward — which is exactly what a person would be doing if they were driving that same session by hand instead of through Native Chat's bubbles.
That's a real constraint, and it shapes what Native Chat should promise. A feature that can only observe a session after the fact has no business pretending it can reach into that session's internal state — which is exactly the judgment call behind the one change to Native Chat we're most willing to talk about.
The Controls We Removed on Purpose
An earlier version of Native Chat had exactly the kind of controls you'd expect a modern chat interface for an AI agent to have: a picker for which model the agent should use, and a selector for how much reasoning effort it should spend. They sat right in the composer, next to the send button, and they looked like real settings.
They came out. Not because they were unpopular, and not because they were hard to build — because they weren't actually wired to anything real. A terminal-layer interface can type a model name into a running session and hope the agent picks it up, but it has no reliable way to confirm the agent actually switched, or to reflect back the model the agent is actually running if something else changed it in the meantime. A control like that doesn't fail loudly. It quietly disagrees with reality, and the person looking at it has no way to know that's happening.
"A setting that might be lying to you is worse than no setting at all. Ours looked exactly like a real model picker, and most of the time it probably even did the right thing — but 'probably' isn't a bar we're willing to ship a control on. We took it out, and the rule we wrote down for ourselves afterward is simple: we don't put a control back in front of a developer until it can actually read the agent's real state and actually change it, not until it can convincingly pretend to."
— Amara Okafor, Head of Developer Experience at ETAPX
That rule now applies to anything new we consider adding to Native Chat. If a control can't genuinely read from and write to the agent's live state, it doesn't ship, no matter how finished it looks in a design file. The reaction from developers who'd been using the earlier version was more mixed than a clean engineering explanation might suggest.
"I noticed the model picker was missing before I saw any announcement about it, and my first reaction was annoyance, not going to pretend otherwise. Then I read why, and it lined up with something that had already bugged me — I'd picked a model in that dropdown once and the response clearly came back from a different one. I'd rather have no control at all than one I have to double-check every time."
— Priti Kapoor, engineering lead at a seed-stage devtools startup and Influxx user
Toward a First-Class Protocol
The plan isn't to leave Native Chat as a terminal skin forever. Some coding-agent CLIs have begun exposing a more structured way for an external client to talk to them — a first-class protocol to speak, instead of only a terminal interface to type into. Where that exists, Influxx's direction is to migrate Native Chat to speak it directly, agent by agent, instead of continuing to infer everything from parsed terminal output.
What Changes Once the Protocol Lands
- Structured session state: a model or reasoning-effort control that can honestly come back, because it would be reading and writing the agent's real state instead of guessing at it.
- Richer approval flows: a permission question becomes a real structured exchange with the agent, not a pattern Native Chat noticed in scrollback and hoped it read correctly.
- Skill invocation as a first-class operation: invoking a named skill becomes something Native Chat tells the agent directly, instead of something it infers from typing a phrase into a terminal and watching what happens next.
This won't land uniformly. It'll arrive agent by agent, in whichever order the underlying CLIs actually expose that deeper protocol, which means for a while Native Chat will be a genuine hybrid: a first-class client for the agents that support it, and the same honest terminal layer for the ones that don't yet.
A Skin, Not Yet a First-Class Client
It's worth naming the trade-off directly instead of leaving it implied. Building a friendlier chat interface on top of an agent's existing terminal session is the fast, pragmatic way to make that agent's work legible to a human being — and it's fast precisely because it doesn't require any single agent vendor to change anything first. We could ship Native Chat for every supported CLI at once, on the terminal interface each of them already had, instead of waiting for dozens of vendors to each publish a deeper integration point on their own schedule.
The honest cost of that speed is that a terminal layer is fundamentally a skin, not a fully first-class client. It can show you what's happening; it can't yet reach in and manage it the way a purpose-built protocol client eventually will. The discipline we're actually holding ourselves to isn't pretending that gap doesn't exist — it's refusing to paper over it with a UI control that looks more capable than the architecture underneath can support. That's the whole story behind the model picker and the reasoning-effort selector we removed: not a feature we lost, but a shortcut we declined to keep taking.
Frequently Asked Questions
Does Native Chat work the same way across every agent CLI Influxx supports?
The underlying mechanism is the same everywhere — Native Chat types into whatever terminal session is hosting that agent and parses what comes back. What varies is how much of that becomes a structured card versus plain conversation, because that depends on how many hook events a given agent CLI emits in the first place. A CLI that reports rich lifecycle detail gives you more structured cards; one that reports less still works, it just leans more on parsed terminal text.
Can I choose the agent's model or reasoning effort from the chat interface?
Not right now, and that's deliberate. An earlier version had that control, and we removed it because it wasn't reliably wired to the agent's actual running state. Until Native Chat can genuinely read and write that setting rather than guess at it, the control stays out rather than risk showing you something that quietly disagrees with what the agent is actually doing. Use the CLI's own controls for that today.
If it's just typing into a terminal, what's the actual advantage over using the terminal directly?
Readability, mostly. A raw terminal session is a fine interface for issuing a command and a poor one for following a conversation once tool calls, diffs, and approval prompts start stacking up in scrollback. Native Chat turns that same session into a composer, a real diff view, and cards you can scan instead of scrollback you have to parse yourself. The terminal is still there underneath, completely unchanged, any time you want it instead.
Do the raw terminal and Native Chat stay in sync if I switch between them mid-session?
Yes, because they're not two separate channels — they're two views onto the same running session. Anything you type in one shows up exactly as if you'd typed it in the other, because as far as the agent is concerned, only one thing is actually happening: someone typing into its terminal.
Will the model and reasoning-effort controls come back?
Once Native Chat can speak a given agent's own structured protocol directly, rather than only its terminal, yes — because at that point the control can actually read the agent's live state and actually change it, instead of presenting a setting that might not match reality. We're not bringing it back before then.
Which agent CLIs does the deeper protocol integration apply to today?
It's still early, and it will land agent by agent rather than all at once, matching whichever CLIs expose that structured protocol first. Until a given agent has that integration, Native Chat runs the same honest terminal-layer approach for it that it uses for everything else today.
Native Chat is a chat interface for AI coding agents that happens to be honest about what it's standing on: a terminal, watched and typed into the same way a person would, not yet a direct line into an agent's internal state. That's a real limitation, and we'd rather describe it accurately than let a slicker-looking control paper over it. The model picker and reasoning-effort selector we removed are the proof that the discipline is real, not just a line in a blog post — and the structured protocol work ahead is how we plan to earn those controls back, honestly this time.
