Everything your team
needs to ship with AI.
Agents, workflows, policies, cost controls, and audit trails - coordinated under one governed control plane. Built for teams that need visibility and control, not just velocity.
Build, configure, deploy.
Your agents, your rules.
Create and manage the agents that power your engineering workflows. Every archetype, skill, preset, and template is versioned, governed, and distributed to your team.
Agent Archetypes
Five built-in archetypes - Researcher, Planner, Executor, Reviewer, and Lex (orchestrator). Each has scoped tool access, model assignment, and sandboxed execution. Create custom archetypes with your own system prompts and guardrails.
File, network, and shell permissions per archetype
Complexity routing picks the right model automatically
Every agent runs in an isolated codemode sandbox
Your own system prompts, personality, and guardrails
Workflow Orchestration
Define multi-stage pipelines with parallel and serial steps. Assign agents per step, set effort levels, add triggers. Workflows are reusable across teams and can be triggered manually, via slash commands, or automatically.
Run independent steps simultaneously
Assign the right archetype to each stage
Kick off workflows from CI, slash commands, or events
Define once, inherit across every team
Visual Workflow Composer
Drag-and-drop pipeline builder with 5 node types - task, checkpoint, logic, start, and end. Connect agents into multi-stage workflows with parallel tracks, approval gates, and configurable failure handling. Validate graphs with AI before execution, then replay runs step-by-step.
Visual canvas with snap grid and auto-layout
Fan-out to multiple agents, fan-in at checkpoints
Check for unreachable nodes, missing agents, cycles
Step through execution visually with state coloring
Reusable tool definitions with scoped permissions and parameter schemas.
Pre-built prompt templates with variable interpolation and versioning.
Organization-wide system prompts inherited by every agent session.
Saved configurations combining model, agent, skill, and instruction sets.
Register and manage Model Context Protocol servers for extended tool access.
Set the rules.
Enforce them at runtime.
Define what agents can and cannot do - file access, network calls, spend limits, approval gates. Policies are evaluated before execution, not after. Every decision is logged and auditable.
Runtime Policies
Policy engine that enforces rules before agents act. File access restrictions, network boundaries, cost limits, human approval gates. Policies run in enforce, warn, or audit modes - switchable per environment.
Rules checked before the action, not after
Restrict access to sensitive paths and endpoints
Require human sign-off for high-risk operations
Enforce, warn, or audit - per policy per environment
Cost Intelligence
Complexity-driven model routing automatically sends simple tasks to cheaper models and complex work to capable ones. Track spend by model, team, project, and agent. Set budgets with alerts before you overspend.
Right model for the right task, automatically
Track spend by model, team, project, and agent
Thresholds, hard caps, and real-time notifications
Bring your own keys for direct provider billing
Audit Trail
Every agent action, every policy evaluation, every cost event - logged and queryable. Export-ready for SOC 2, ISO 27001, and internal reviews. Configurable retention from 30 days to unlimited.
Every tool call, file edit, and API request logged
Policy breaches categorized in real time
SOC 2, ISO 27001, and custom compliance formats
30 days to unlimited, configurable per org
Route requests to specific models or agents based on content, user, or cost criteria.
Automated AI-powered code review with configurable rulesets and severity levels.
Run governance checks in your pipeline. Block deploys that violate policies.
Separate configs for dev, staging, and production with environment-specific policies.
Aggregate risk scores across teams with drill-down into individual violations.
See everything.
Miss nothing.
Real-time visibility into every agent session, every model call, every cost event. DORA metrics, developer experience signals, quality analysis, and infrastructure health - all in one place.
Engineering Intelligence
DORA metrics, developer experience signals, and agent impact analysis across your engineering organization. See how AI accelerates your teams - and where it doesn't.
Deployment frequency, lead time, MTTR, change failure
Measure AI contribution to engineering velocity
Satisfaction, flow state, cognitive load tracking
Compare performance across squads and projects
Real-time Dashboard
Monitor every session, every cost, every model call as it happens. Spot anomalies before they become incidents. One dashboard for engineering, finance, and operations.
Watch active agent runs as they execute
Spike alerts for cost, latency, and error rate
Latency, token usage, and error rates per model
One dashboard for eng, finance, and ops
Live feed of every agent action as it happens across your organization.
Code quality trends, test coverage impact, and technical debt tracking.
Token consumption, session counts, and adoption metrics by team and user.
API latency, error rates, and throughput across all connected providers.
Plan, track, investigate.
AI-native project management.
Issue tracking, kanban boards, investigation workflows, and PR review tracking - all connected to your agent activity. When an agent opens a PR or files a bug, it shows up here automatically.
Issue Tracking
Track bugs, features, and tasks with agent-generated context. Issues link to the sessions that created them, the PRs that fix them, and the policies that govern them. Filter by assignee, status, priority, or agent.
Issues automatically reference the session that created them
AI-suggested priority based on impact and dependencies
Link to PRs, sessions, audit events, and investigations
Batch update status, assignee, and priority
Investigations
When something goes wrong, investigations aggregate the full timeline - agent sessions, policy violations, code changes, and infrastructure events. Root cause analysis with AI-assisted summarization.
Full chronological sequence of events leading to an issue
Automated root cause analysis across sessions and logs
Route to PagerDuty, Slack, or custom webhooks
Generate incident reports with recommendations
Visual board with drag-and-drop, WIP limits, and swimlanes by team or priority.
Track pull request reviews across connected repositories, grouped by team.
Sprint velocity, burndown charts, and completion metrics across all projects.
Your org, structured.
Teams, knowledge, integrations.
Manage your team, control access, curate connected knowledge sources, and connect to the tools your team already uses. SSO, RBAC, SCIM provisioning, and encrypted credential storage.
Team Management
Role-based access control with admin, manager, and member roles. SSO via Auth0 with SAML and OIDC support. SCIM provisioning for automatic user sync from your identity provider. Invitation workflows with approval.
Admin, manager, and member roles with granular permissions
SAML and OIDC via Auth0 with custom domain support
Automatic user provisioning from your identity provider
Email invites with role assignment and approval workflow
Knowledge Sources
Backend-managed organizational knowledge that agents can reference during execution. Ingest documents, sync from Confluence and Jira, or promote linked resources into searchable knowledge sources with provenance.
Documents, repositories, Confluence spaces, and Jira boards
Knowledge lives in backend services rather than local mirrors
Search results retain source, freshness, and citation context
Agents retrieve connected knowledge during execution
OAuth-based integrations with GitHub, Atlassian, Linear, and PagerDuty.
Connect OpenAI, Anthropic, Google, and custom providers with BYOK support.
Slack, WhatsApp, and email notifications for policy violations and alerts.
Billing, tier management, API keys, and organization-wide configuration.
Group work by project with separate budgets, policies, and team assignments.
Domain-specific terminology enrichment for more accurate agent responses.
One set of rules.
Every team follows them.
Define how AI operates in your organization - who can do what, which models to use, what gets logged, and when humans approve. Then let every team and every agent inherit it.
Sandboxed Execution
Agents write and run code in isolated sandboxes. Every action is validated before it touches your codebase.
Codebase Awareness
Every agent understands your codebase - functions, types, dependencies, and relationships.
Autonomous Agents
Deploy agents into CI/CD that follow your team's standards. PR reviews, security checks, and deployments - governed by your rules.
Complete Visibility
Every agent action, every cost, every policy decision - logged and queryable across your organization.
Declarative Workflows
Define multi-stage workflows once. Every team inherits the same review, test, and deploy process.
Parallel Work, Zero Conflicts
Multiple engineers and agents work on the same repo simultaneously - each in an isolated branch.
Institutional Knowledge
Decisions, patterns, and context persist across sessions. New team members inherit organizational knowledge.
Runtime Policies
Set boundaries on file access, network calls, and spend. Policies are enforced at runtime - agents can't bypass them.
Your workflow.
Your environment.
VS Code extension, terminal CLI, or desktop app. Every client runs the same orchestration engine with the same policies. Pick the interface that fits - governance follows.
The editor, augmented.
Multi-agent execution inside VS Code, backed by the same routing, policy, indexing, and recovery systems as the full runtime.
Use Lex inside VS Code Chat, not just a custom sidebar
Hub view for orchestration, conversation panels for deep work
Spin up conversation-specific git worktrees when a task needs a clean lane
Review, keep, or undo generated changes before they land
Fan out specialists and watch each lane complete independently
Full tool timelines survive tab closes, restores, and panel reopen
Pull in files, selections, terminal output, and problems with token discipline
Reindex and search repo knowledge without leaving the editor
Route simple and heavy tasks to the right model tier automatically
Catch silent hangs from lost progress or lost communication
Turn staged diffs into commit messages directly from the extension
Health checks, auth status, model settings, and org policy refresh built in
LEX - Your SDLC, orchestrated.
Model: claude-sonnet-4-20250514 Status: ● Ready User: jamie.l Org: acme-corp
Welcome to Lex - Your SDLC, orchestrated.
/model • Switch provider, model, or agent
/conv • Browse & switch conversations
/new • Start a new conversation
/help • Show all commands
✦ Lex → dispatching workflow code-quality-audit
├ Stage 1 scan ········ ✓ 3 subagents, 847 files
├ Stage 2 analyze ····· ✓ 12 findings
└ Stage 3 report ······ ⧖ generating...
The terminal, unleashed.
Full agentic runtime in your terminal. Same engine, same policies, no GUI required.
Model switching, conversations, history
Pick up where you left off across restarts
Run workflows unattended in CI/CD pipelines
Pipe output to scripts and other tools
Lex, Research, Plan, Execute, Review
Right model for the right task, automatically
Projects
🛠 Tooling
⚙ Settings
❆ Lex → dispatching feature-implementation
├ Research ········ ✓ analyzed 23 files
├ Plan ··········· ✓ 4-step migration
├ Implement ···· ⧖ modifying 6 files...
Msrc/auth/session.ts
Msrc/auth/middleware.ts
Asrc/auth/jwt-provider.ts
3 files · +84 -12
@@ session.ts @@
- const token = crypto.random()
+ const token = jwt.sign(payload)
- res.cookie('sid', token)
+ res.cookie('jwt', token)
The desktop, refined.
Native desktop app with the same orchestration engine. Offline-capable, multi-project workspaces, and a built-in review pane for staging diffs before they land.
Organize conversations by project folder
Stage, revert, and commit diffs without leaving the app
Full shell with xterm.js, resizable drawer
Pick up where you left off across restarts
Same policies, models, and audit trails as the extension
macOS, Windows, and Linux via Electron
See it in action
A fully interactive demo dashboard with realistic data. No sign-up required. Or schedule a 30-minute walkthrough with the team that built it.