Software Architecture for Agentic Engineering
TENET is the architecture layer for agentic engineering. Define your software architecture once, then give every AI agent, every IDE, and every developer the same structural truth in real time.
Open standard. CLI native. Works with Claude Code, Cursor, Windsurf, Codex, Gemini CLI, and any MCP-compatible agent.
tenet — a principle that is an accepted belief of a particular group.
Vibe coding does not scale.
AI coding agents are fast, but without architecture context they violate boundaries, duplicate modules, and quietly rot the system they are supposed to accelerate.
Agents create files in random places, duplicate existing modules, and ignore the shape of your system because they cannot see it.
Markdown prompts and copied rule files fork over time. Different agents get different instructions. Standards erode.
An agent touching a service has no idea what constraints apply, what depends on it, or which specifications are already in flight.
Architecture as a living graph.
TENET models your software architecture as a connected, queryable graph. Agents ask for working context and get the exact rules, qualities, skills, dependencies, and specs that matter to the component they are changing.
- Components, connections, rules, skills, quality attributes, and specs are linked in one graph.
- Agents query only the context that is relevant to the component they are touching.
- Humans review and refine the architecture while agents execute with governed context.
Everything agents need to build correctly.
From graph structure to quality constraints to reusable skills, TENET gives agents governed context instead of vague prompt lore.
Model containers, components, connections, stores, and external systems on a visual canvas with zoom, layout, and editing built in.
One query returns hierarchy, dependencies, applicable rules, relevant skills, quality constraints, and active specifications.
Define rules once at org or project scope and surface them automatically where agents and humans need them.
Attach concrete non-functional constraints to the components they govern so agents can build against real targets.
Store implementation guidance, patterns, and domain-specific knowledge that agents can read when shallow prompts are not enough.
Coordinate architect, builder, and reviewer agents around the same graph instead of relying on hardcoded prompts and checklists.
Three steps to governed AI engineering.
Model the structure, connect the tools, then let agents work against live architecture instead of guesswork.
Capture containers, components, connections, quality goals, and rules in the web interface so the structure is explicit and queryable.
Add TENET through MCP or the CLI so your tools can fetch architecture context instead of guessing.
Agents fetch the relevant working context before they write code, while humans review and steer architectural decisions.
{
"mcpServers": {
"tenet": {
"url": "https://api.tenet-mcp.io/mcp"
}
}
}
> curl -fsSL https://www.tenet-mcp.io/cli/install.sh | bash
> tenet login
> tenet get-working-context --path backend/auth
{
"component": "Auth Service",
"rules": [
"No auth bypass in production code"
],
"quality_attributes": [
"Latency under 80ms",
"No N+1 queries"
],
"skills": [
"DynamoDB access patterns",
"MCP auth conventions"
],
"active_specs": [
"oauth-session-hardening"
]
}AI moves fast. Architects stay in control.
TENET does not replace architectural judgment. It gives humans a system for setting intent, reviewing structural changes, and coordinating agents around that intent.
- Architects define and refine the graph before broad agent execution starts.
- AI-drafted architecture edits stay reviewable in the Web UI instead of disappearing into prompt history.
- Reviewers validate changes against live rules and constraints, not stale documentation.
Meets you where you work.
TENET is a visual command center for humans, an open MCP surface for agents, and a deterministic CLI for automation.
Interactive architecture graph, rule management, quality editing, and human-in-the-loop review for AI-drafted changes.
Native tool access for Claude Code, Cursor, Windsurf, Codex, Cline, Zed, and any MCP-compatible agent.
JSON-first contracts and deterministic exit codes for terminal workflows, automation, and multi-agent orchestration.
One source of truth. Every agent.
TENET centralizes architecture, rules, and quality standards so your context survives tool changes instead of being tied to one editor or one prompt format.
Scales from solo developer to enterprise.
The same graph helps an individual developer stay coherent and helps an organization keep many teams aligned.
- Multiple projects, one standard
- Any agent, your rules
- Branch-aware architecture
- Shared architectural guidelines
- Unified knowledge for all agents
- Living documentation for onboarding
- Organization-level standards
- Cross-project quality gates
- Architecture decisions with lineage
Not another .md file. A living architecture.
TENET is not prompt duct tape. It is a governed architecture system that agents can query and humans can steer.
Flat files dump the entire handbook on every agent. TENET returns the rules and constraints for the component that is actually being changed.
TENET links rules, qualities, skills, specs, and structure together so working context is the union of what matters right now.
TENET keeps a human architect in the loop. Agents move faster, but structural intent still belongs to the people designing the system.
Start quick. Scale when you are ready.
Every plan includes the graph, working context, CLI, MCP access, rules, quality attributes, and skills.
- 1 organization
- 3 projects
- Unlimited MCP queries
- Full CLI access
- Community support
- 1 organization
- Unlimited projects
- Unlimited MCP queries
- Priority support
- Team collaboration for up to 5 members
- Unlimited projects and members
- Organization-level rules and templates
- Priority support
- Full CLI and MCP access
- SSO coming soon
Pricing is preliminary and subject to change.
Your agents are writing code right now. Do they know the architecture?
Give every AI agent and every developer a structural understanding of your codebase. Define once, govern everywhere.