The execution graph for engineering teams shipping with AI.
Vector is an AI-native workspace graph: the work your team does, the knowledge that explains it, the customer signal that drives it, and the agents working alongside them — connected and queryable.
The workspace
One surface for the work, the request, and the pull request.
Open an issue in Vector and you see the customer who asked, the sprint it landed in, the branch it shipped on, and who's reviewing it. No tab-hopping, no broken links between systems.
More than a tracker
Docs, canvases, and code intelligence — built in, not bolted on.
The same workspace where your team tracks work also holds the documents that explain it, the diagrams that map it out, and the local index your AI agents use to understand the codebase. Nothing lives in a separate tool you have to keep in sync.
- Read context bundle
- Inspect North Graph
- Save docs or canvas evidence
- Ship with source IDs
What ships with the workspace
More than tickets: docs, canvases, agent access, and a public contract.
Everything below is in the same workspace as your issues, under the same permissions your team already has. Nothing is a side product or a separate paid add-on.
Workspace docs are part of the work graph.
Specs, runbooks, decisions, and handoff notes live in collections with pinned state, review ownership, comments, version restore, and links to issues, projects, and initiatives.
Canvas is first-party, not an embedded whiteboard.
Vector stores canvas scenes in the workspace, with frames, text, tables, mind maps, freehand notes, version history, realtime save events, and artifact links.
Knowledge artifacts connect back to execution.
Documents and canvases can be linked to issues, projects, and initiatives so strategy, specs, diagrams, decisions, and delivery work stay queryable in the same permissioned system.
Daily issue work has real operating controls.
My Issues, Inbox, Feed, saved views, facets, grouping, sorting, templates, recurring issues, SLAs, insights, and exports are all workspace-native surfaces.
Developer access is visible and revocable.
Workspace owners can manage scoped tokens, agent principals, allowed teams, allowed tools, GitHub repositories, and credential lifecycle from the product instead of hidden configuration.
The public contract is documented for humans and agents.
/documentation, /docs, and /llms expose setup guidance for the CLI, hosted MCP, North Graph, production checks, error shapes, and handoff workflows.
North Graph
Give every coding agent a deterministic map of your codebase.
North Graph is Vector's local code intelligence layer: a structured map of symbols, routes, side effects, tests, and project policy exposed through a local MCP server. Codex, Claude Code, Cursor, CI, or your in-house agent can work from the same evidence-backed view of what a change touches and what needs to be checked.
- Local code graph. Your repository becomes a navigable map of symbols, imports, routes, effects, tests, and policy rules while source stays on your machine.
- Impact-aware diffs. Every change maps back to the files, routes, workflows, tests, and policies it touches before review starts.
- Effect and policy evidence. Database writes, secret reads, network calls, email sends, and auth-sensitive paths become machine-readable facts for CI, PR comments, and workspace records.
- Agent-ready and model-agnostic. Bring Codex, Claude Code, Cursor, a local model, or your own agent. North Graph supplies deterministic context without tying the workflow to one provider.
~/acme · vector north
$ vector north diff analyze --base main --json
{
"base": "main",
"files_changed": 14,
"symbols_changed": 22,
"effects": ["database_write", "email_send"],
"routes_impacted": ["POST /workspaces/:slug/issues"],
"tests_impacted": 41,
"policy_violations": 0,
"verdict": "clean"
}
$ vector north mcp
listening · stdio · 11 tools registered
$ ▍Agents, first-class
Built for both kinds of teammate.
Whatever a person on the team can do in the UI, your scripts can do from the terminal and your agents can do through MCP. The same data. The same permissions. The same audit log. No back door.
Every agent gets its own identity and a policy that says exactly what it's allowed to read, write, and approve — so an automation mistake can't reach into a private team or a workspace it doesn't belong to.
- Stop building glue code. A typed JSON contract, predictable errors, and idempotent writes — so an agent can retry a tool call without corrupting state.
- Share context, not screenshots. Context bundles hand an agent the issue, the customer behind it, and the linked GitHub activity in a single permission-filtered JSON payload.
- No back door for agents. The same workspace and private-team checks that protect a person on the team apply to every CLI, MCP, and webhook call.
- Always know who did what. Every agent action shows up in Feed, Inbox, and the audit log next to its human counterparts — so reviewing what shipped, and why, is the same for code an agent wrote as code a person wrote.
search_workPermission-filtered issue search with filters.create_issueCreate an issue in an accessible allowed team.update_issueUpdate allowed issue fields with idempotency support.add_commentAdd a comment to an accessible issue.read_context_bundleRead an agent-ready issue context bundle.request_approvalRecord a structured approval request placeholder.
Closed-loop execution
From the customer ask to the shipped fix, on one timeline.
Vector connects the signal that motivated the work to the change that closed it. Every stage in the loop stays linked in one queryable graph — visible to your team in the UI, to your scripts in the CLI, and to your agents through MCP. The work updates the graph; the graph updates strategy.
- 01Signal
Customer asks, support threads, incidents, analytics, founder direction — captured with source attribution.
- 02Intent
Why the work exists: customer pain, strategy bet, incident follow-up, or technical debt. Linked back to its signal.
- 03Plan
Projects, sprints, initiatives, and milestones. Owners and deadlines are explicit; rollups are computed, not maintained.
- 04Execution
Issues, branches, pull requests, reviews, and deploys flow into the same record — humans and agents writing side by side.
- 05Evidence
North Graph reports, test runs, deploy markers, and customer outcomes attach to the work that produced them.
- 06Outcome
Metrics, feedback, and experiment results land back on the originating intent so teams can see what worked.
- 07Learning
Insights feed the next signal: roadmap adjustments, policy changes, deprecated bets — recorded, not lost to chat.
Programmatic access
Humans use the UI. Scripts use the CLI. Agents use MCP.
The important rule is parity. A caller should not get more access because it used a token instead of the browser. Workspace, private-team, audit, and scope checks stay consistent across every surface.
UI
The Vector web workspace. Command palette, keyboard shortcuts, and real-time updates over the same record graph.
CLI
vector commands run under scoped tokens. JSON output by default, stable exit codes for CI, retries built into the client.
MCP
Hosted workspace MCP exposes product tools. Local North Graph MCP exposes repo intelligence. Capability policy is applied per agent principal.
What's in the box
One place for what your teams already do.
Worklists, sprints, projects, customer requests, docs, canvases, and the pull request that closes them all share the same workspace graph. A triage in one place updates the sprint board, the customer's request, and the linked pull request — without anyone running a sync.
Run multiple teams in one workspace
Engineering, product, design, and ops — side by side, each with their own boards, sprints, and triage inboxes. Private teams stay private from search, exports, notifications, and any agent that shouldn't see them.
Plan a sprint and a quarter from the same place
Sprints for the week. Projects for the quarter. Initiatives across teams. Status rolls up automatically, so no one is maintaining a spreadsheet that re-describes the work.
Customer signal that survives the handoff
Requests and intake forms feed real engineering work, with the requester, the context, and the impact attached. Every shipped fix can still answer who asked and why.
Docs and canvases live with the work
First-party documents with version history, review, and comments. Canvases with tables, mind maps, and freehand. Linked to the issues and projects they explain — not parked in a separate wiki that nobody updates.
GitHub, attached
Branches, commits, and pull requests link to issues by name and number. The shipping history sits inside the work item, and reviewers can see the customer behind the change.
Triage that doesn't lose the new stuff
A team inbox catches new issues, asks, and customer signal before they hit the board. Accept, route, decline, or merge as a duplicate — with an audit trail showing what happened to anything.
Insights without a separate BI tool
Save the views you actually use. Cycle time, throughput, customer impact, and sprint health pull from the same records you work in. No exports, no extra dashboard product to pay for.
First-party CLI and MCP
Drive the same workflows from a terminal or an agent. CLI and MCP requests run under the same permissions and audit trail as a person on that team — no separate access path to maintain.
Security
Your teams' work stays inside the lines you draw.
One permission model covers the UI, the API, the CLI, the agents you give access to, the real-time stream, and the export button. There is no surface that can quietly route around it.
- Membership decides what you see.
Workspace and team membership is resolved server-side on every request. The URL in the address bar can't grant access the user doesn't already have.
- Private teams really are private.
Their work doesn't appear in workspace search, exports, notifications, or the activity feeds of people who aren't members. Agents inherit the same rule.
- Sensitive actions are recorded.
Invites, role changes, exports, deletes, GitHub installs, and billing changes write to an append-only audit log. When something goes wrong, you can answer what changed, by who, when.
Pricing
Simple per-seat pricing. No quote required.
Start on Free. Upgrade when you need unlimited issues, more teams, or private-team access. Billed per user, monthly or annually — annual saves around 18% on every paid tier.
Free
For solo developers and teams trying Vector out.
$0/ user · month
Free, forever, no card required.
Start free- 300 issues per workspace
- Up to 2 teams
- Unlimited members
- GitHub-linked development
- First-party CLI and MCP
Basic
For engineering teams running day-to-day work in Vector.
$9/ user · month
Billed annually at $108/user/year.
Choose Basic- Everything in Free
- Unlimited issues
- File uploads
- Up to 5 teams
- Customer requests (Asks)
Business
For larger orgs with multi-team and access-control needs.
$14/ user · month
Billed annually at $168/user/year.
Choose Business- Everything in Basic
- Unlimited teams
- Private teams
- Guest accounts
- Audit log export
All plans include workspace isolation, GitHub-linked development, first-party CLI and MCP, audit trails, and workspace login. Volume pricing and SOC 2 add-ons available once you're past 50 seats.
Questions
Common questions, answered up front.
Who is Vector for?
Product and engineering teams that ship software together, and want one place that holds the work, the reason behind it, and the change that closed it — for the people on the team and the AI agents working alongside them.
What makes Vector different from other trackers?
Two things. The surface goes wider than issues — docs, canvases, customer requests, GitHub activity, and the work shipping against them all live in the same queryable workspace graph, not in separate tools held together by links. And agents are a built-in audience: anything a person can do in the UI is available to scripts through the CLI and to agents through MCP, under the same permissions and the same audit log.
Does Vector include docs and visual planning?
Yes. Workspace documents and canvases are first-party — with version history, review, comments, and links back to the issues, projects, or initiatives they belong to. They aren't a separate wiki you forget to keep up to date.
What is North Graph?
Vector's local code intelligence layer. It maps symbols, routes, side effects, tests, and project policy on a developer's machine, then exposes that deterministic code map through local MCP so compatible agents and CI can work from the same evidence. Source code never leaves the machine.
Which agents and models does Vector support?
Any MCP-capable agent — Claude Code, Codex, Cursor, Windsurf, your in-house agent, or a local model. Vector and North Graph are model-agnostic. You bring the agent and pay for inference where you already do.
Does Vector send my code anywhere?
No. North Graph indexes locally and stays on the developer's machine. Workspace data lives in your tenant; the CLI and MCP surfaces operate on records, not source. There is no source-code upload by default.
How does Vector keep agents inside the rules?
Every agent gets its own scoped identity, with a capability policy that decides what it can read, write, and approve. CLI, MCP, and webhook calls are authenticated, authorized against the same workspace and private-team rules a person is, and written to the audit log. Agents don't have a back door the UI doesn't have.
How is data isolated between teams and workspaces?
A workspace is the boundary. Membership is resolved server-side from the workspace in the URL on every read and write. Search, exports, notifications, real-time updates, and GitHub-linked activity all respect it. Private teams stay private within a workspace, even from agents.
Which integrations are available today?
GitHub is the first-party integration: pull requests, branches, and commits attach to issues by name and number. The first-party CLI and MCP server ship with Vector. Other third-party integrations are deliberately out of scope for the MVP.
How much does it cost?
Free is $0 with 300 issues, 2 teams, and unlimited members. Basic is $9 per user per month (annual) or $11 (monthly) for unlimited issues, file uploads, and 5 teams. Business is $14 per user per month (annual) or $17 (monthly) for unlimited teams, private teams, and guest access. Annual saves about 18% on both paid tiers.
Get started
Stand up a workspace in a few minutes.
Create an account, name a workspace, and invite the rest of the team when you're ready. Add GitHub, give your CLI a token, and point your agents at MCP whenever it suits you.