Sensei
Strategic mentor
MentorSynthesizes your goal tree from canonical docs, observes execution drift, re-grounds you with one clear focus per day.
Capability · AI Copilots
AI assistants embedded in the tools your team already uses.
Generic chat doesn't change how your team works. A copilot tuned to your domain — in the tools your team is already in — does. Agix builds copilots that draft, review, and decide alongside operators, with explicit guardrails and full observability.
What an Agix copilot is
A copilot is an AI assistant embedded inside the tool your team already uses, tuned to your data, your voice, and your rules. Unlike an agent — which works on its own surface and manages its own queue — a copilot lives next to a human, drafting and suggesting while the human approves and ships. Same intelligence, different runtime envelope.
- Embedded where work already happens — Slack, Salesforce, internal tools
- Tuned to your domain — your data, your voice, your rules
- Human-in-the-loop where it matters; autonomous where it doesn't
- Per-team observability and cost controls baked in
- Provider-portable across Anthropic, OpenAI, and enterprise endpoints
Agent vs. Copilot — same intelligence, different runtime envelope
The clearest way to understand the choice. An Agix Agent lives on its own runtime; you commission a role and the agent works it. An Agix Copilot lives inside the tool your team already uses; the host's UI carries it, your intelligence powers it.
Meet the Vespers — agent marks by type
Each Agix agent wears a Vesper — the seven-hex Agix mark rendered in the color of its agent type. As the roster grows, new agents inherit a type and a color: leadership, development, task, mentor, security, curation. The visual system scales — every agent reads in a glance, no character design required per role.
Leadership
Strategic direction-setting. Agents that act with executive authority on behalf of the operator.
Development
Build, architect, refactor. The structural foundation — agents that shape and ship code.
Task
Operational doers. Queue runners, triagers, orchestrators — agents that move work through pipelines.
Mentor
Coaching and guidance. Agents that observe drift, re-ground the operator, and surface what matters.
Security
Pentest, compliance, audit. Agents that protect the foundation and surface risk.
Curation
Brand guardrails, voice and visual review. Agents that keep what ships consistent with what was promised.
Architect
Spec relevance + roadmap awareness
DevelopmentPer-spec relevance scoring and architecture-impact annotation across the agent fleet. The structural foundation of the build.
Director
Orchestrator
TaskReads replies to agent briefings, classifies intent, executes safe verbs automatically. Git custodian auto-reaps merged branches.
Curator
Brand guardrail
CurationReviews deployments against the Sumi & Kin rubric — lockup, palette, typography, structure, voice — pre-deploy.
Secretary
Chief of Staff
TaskReads inbox twice daily, classifies and summarizes, drafts replies, delivers a Sumi & Kin briefing letter.
The stack we install
Six layers — built on the same evaluation and observability standards as every other Agix capability — that turn a host tool into a copilot-equipped workspace.
Source data + access control
What the copilot can read, scoped to the user's actual permissions. The copilot never sees what the user wouldn't — and the audit trail proves it.
Context retrieval
Pulls the right slice of your knowledge for this user, this task, this moment. Built on the Second-Brain layer when one exists, on direct queries when it doesn't.
In-app surface
Sidecar panel, slash command, inline widget — embedded in the host tool's UX so it doesn't feel like a separate app the user has to tab to.
Reasoning + draft loop
The actual LLM work — producing the draft, the rewrite, the rationale, the suggested action. Versioned prompts, structured outputs, predictable shape.
Human-in-the-loop control
The human always sees, edits, approves before anything leaves the copilot. Default refusal posture on irreversible actions. The copilot drafts; the human ships.
Telemetry + cost dashboard
Per-team observability, per-user token ceilings, refusal logs, feedback capture. Operated by your team from day one of go-live.
What your team owns at handoff
The copilot is yours from day one of go-live — prompts, evals, adapters, integration code, dashboards. Agix steps back; the copilot keeps running.
The prompt set
Versioned in your repo. Your team modifies the system prompts, refusal rules, and tone parameters without us in the loop.
The eval set
Canned regressions seeded from real cases in your workflow. Your team adds new cases as the copilot encounters new territory; releases gated on green.
The context adapters
The code that pulls your data into the copilot's view — your CRM, your ticketing system, your knowledge base. Adapters live in your repo, run in your infra.
The in-tool integration code
Word add-in, Salesforce package, Slack bot, admin-UI panel — whichever host you embed in. Code is yours, signed by your team, deployed through your pipeline.
Observability + cost dashboards
Per-team traces, per-user cost views, refusal logs, feedback history. The same dashboards Agix uses during Build are the dashboards your team uses to run it forever.
When this tier fits
Four buyer situations where commissioning an Agix copilot is the right move.
"Our experts are bottlenecked on the same five review tasks."
The copilot takes the first pass — drafts the response, flags the risk, suggests the rewrite — and the expert reviews. The bottleneck becomes a review queue, not a writing queue.
"We have a tool everyone lives in and want AI inside it, not next to it."
Embedding beats adjacent. If your team is in Salesforce, Word, or your own admin UI all day, the copilot lives there. No tab-switching, no separate login, no behavioural change required.
"Domain accuracy matters more than novelty."
The copilot is tuned to your data, your rules, your voice — and gated by an eval set that ships with it. The win is not creative output; the win is consistent, accurate, defensible work at higher throughput.
"We need humans in the loop — but as the approver, not the drafter."
Drafting is the slow part. Reviewing is the fast part. The copilot inverts the work: it drafts everything, the human reviews and approves. Audit trail is mandatory; refusal posture is default-on for irreversible actions.
When to pick something else
Copilots embed where work happens — but not every problem is shaped like an embed. Here's how to tell.
If the work needs its own surface, not embedding
When the role is autonomous and recurring — research, drafting, triage running on its own schedule — what you need is an Agix Agent, not a copilot. Same intelligence, but living in its own runtime instead of inside an existing tool.
Explore Agix Agents →If the AI is for your customers, not your team
Customer-facing AI features are a different shape — per-tenant safety, brand-aligned voice, rollout flags, eval at scale. AI-Powered Products is the tier for that work.
Explore AI-Powered Products →If your knowledge isn't queryable yet
A copilot is only as good as the substrate it reads. If your institutional knowledge is scattered across drives, wikis, and threads — and not queryable through a single surface — start with Second-Brain. The copilot will land on top of it.
Explore Second-Brain Knowledge Systems →Worked example: a permit-review copilot for a mid-sized city
An illustrative scenario showing how this tier shows up in practice. The shape mirrors how Agix builds copilot engagements; the client and specifics are composite.
The brief
“Our planning department reviews thousands of building permits a year against a code that runs to several hundred pages, plus precedent from past approvals and denials. Reviewers spend most of their day cross-referencing the submittal against code, looking up similar past decisions, and drafting the response letter. We want a copilot in our existing review console that does the cross-referencing automatically, surfaces the relevant precedents, and drafts the response so the reviewer can sign off instead of compose.”
The shape we'd build
A copilot panel docked alongside the existing permit-review UI. Reads the submittal package, the current code, and the precedent corpus of past approvals and denials. Produces a structured pre-review — code: pass/flag per section, precedent: similar past decisions with rationale, completeness: missing-submittals checklist — with citations back to the exact code clauses and historical permits that triggered any flag.
For each flag, the copilot drafts the explanatory paragraph the reviewer would write, in the department's house tone. The reviewer reads the pre-review, edits where needed, and approves or sends back. The copilot never sends anything itself; the department's reviewer always ships. Every decision logs the citations the copilot pulled, so a future appeal can reconstruct exactly which code clauses and precedents drove the call.
What the department owns when we step back
The integration code embedded in the review console, deployed through the city's pipeline. The prompt set tuned to the department's tone and refusal posture, versioned in their repo. The eval set seeded from real review decisions, extended by the department's staff as new patterns emerge. The per-reviewer dashboards. The copilot runs in the department's environment from day one and keeps running there — Agix steps back, the panel stays.
Talk through a copilot for your team
Start with a Discovery conversation. We'll talk through where the copilot would live, the work it would do, and what shipping it into your stack looks like.