Tangigo Logo
ProductFeaturesPricingNotesResourcesSupport
LoginStart free

Build software with governed AI agent squads.

Tangigo gives your agents something to be accountable to: a registry of what your organisation already has, a control plane that decides what may happen and by whom, and one build path that takes a story to a single reviewed pull request.

Start freeSee how it works

Free tier, no credit card. Sign in with email, Google, GitHub or Microsoft.

Products & modulesWeb appAPIMobilegovernance flows downassets flow back upRegistrywhat the organisation hasAgents & skillsAPIsPrinciplesData modelsComponentsControl planewhat may happen, by whom, at what costPrincipalsPoliciesApprovalsCredentialsAuditRuntimethe agent harness that does the workSquadsIsolated build jobPull requestVerification

A registry of what your organisation has

Agent definitions, skills and tools, APIs and contracts, principles and standards, capabilities, data models, reusable components and integrations — one org-scoped catalogue instead of a wiki nobody trusts. Every write is a new version.

  • One list pattern: owner, version, lifecycle, used by
  • Lifecycle from proposed through approved, active, deprecated, retired
  • Approvals recorded server-side, never claimed by the caller
  • Deleting an entry something depends on is refused, and says by what

A control plane, and checkpoints where the work happens

Principals and teams, policies, approvals, compliance frameworks, credential bindings and an audit trail. When work deviates from one of your principles, a checkpoint card appears inline — in the wizard, in grooming, in the squad room — not on an admin page a week later.

  • The card states the rule, the deviation and who must approve
  • Reject, grant a scoped time-boxed dispensation, or relax the principle
  • Either way an ADR is written and the registry updated
  • Agents are principals in their own right, never acting as a user

Agent squads, and exactly one build path

A definition plus a control-plane profile is provisioned into named agent instances; a squad of people and agents is staffed onto a backlog item. When a story is built, it is built one way: an isolated job clones the repo, runs architect, developer and tester over one working tree, and opens a single pull request.

  • Every build is an isolated job — code is never generated in a shared process
  • One story, one branch, one pull request for a human to review
  • Progress is checkpointed, so a build survives closing the browser
  • After merge, the test matrix runs against a per-module baseline

Documents and diagrams as the substrate

Specs, stories, ADRs, architecture views and policies are Markdown documents with typed references, versions and an approval workflow. Diagrams are draw.io, versioned, and referenced by id from the documents that use them.

  • Edited in place, with the version history and the diff kept
  • Typed references give you backlinks, not a search-and-hope
  • Entity diagrams generated deterministically from your data models
  • Approval is a state on the document, not an email thread

Search that is also how the agents are grounded

One hybrid search across documents and diagrams, filtered by what the caller may actually see. The same index is what an agent reads before it answers, so the answer comes from your registry rather than from whatever was in the chat.

  • Scope pre-filtered from the caller’s memberships
  • Full-text and vector results combined, with honest fallbacks
  • Agents query it as a skill, under the same access rules
  • An ungrounded turn says so rather than guessing

Skills, MCP servers and credentials that stay secret

Agents attach skills, never raw tools. Register an MCP server and its tools are discovered and installed as a skill; publish an API entry and it generates one for you. Credentials are bound to the skill, and the secret is write-only.

  • Tool → skill → agent definition, so permissions are reviewable
  • MCP sources re-discovered on demand, with the tool-set diff shown
  • The entry holds an opaque reference; the secret is never readable back
  • Resolved per call, scoped no wider than the tool that needs it

One way a story gets built

Not a chat window that sometimes writes files. A single path from a grounded story to a reviewed pull request, with the same checkpoints every time.

01

A story, grounded

The backlog item is a document with typed references into the registry, so the squad starts from your principles, APIs and data models rather than from a paragraph of chat.

02

Dispatched to an isolated job

Nothing is generated in a shared process. The build is queued, then runs in a job of its own that clones the module repository onto its own disk and cuts the story branch.

03

Architect, developer, tester

The squad works over that one tree — reading files, writing files, running the tests — while every checkpoint and every activity line streams back into the squad room.

04

One pull request

The job commits, pushes and opens a single pull request for a human to review. Close the browser and the build carries on; the story itself records the phase it reached.

05

Verified after merge

The merge triggers the test matrix against a per-module and per-environment baseline. A test type that timed out or was skipped is reported as exactly that — it never counts as verified.

Named agents, not anonymous prompts

A definition carries its skills, its control-plane profile and how much it may do unattended. Provisioning turns it into named instances that are principals in their own right — they appear in the audit trail under their own identity, never under yours — and a squad of people and agents is staffed onto a backlog item.

Developer

Code generation, module management, deployments

Tester

Test creation, execution, quality analysis

UX Architect

Screen inventory, IA, user flows, low-fidelity wireframes mapped to acceptance criteria

DevOps

Infrastructure, deployments, monitoring

Analyst

Reports, metrics, data analysis

Governance

Compliance review, architecture standards, ADRs

One catalogue, and the things that fill it

Register an MCP server and its tools arrive as a skill. Publish an API and it generates one. Everything an agent may reach is an entry somebody owns, versioned and reviewable.

In the registry

Agent definitions
Skills & tools
APIs & contracts
Principles & standards
Capabilities
Data models
Reusable components
Policies & compliance
ADRs
Credential bindings

Sources & formats

MCP servers
OpenAPI
GitHub
Anthropic Claude
OpenAI
Google Gemini
draw.io
Markdown

0

Registry kinds

0

Agent definitions

0

Lifecycle states

0

Pull request per story

Simple, Transparent Pricing

Start free. Scale as you grow. No surprises.

Give your agents something to be accountable to.

Create an organisation, add a product, and watch the first story go from a grounded spec to a reviewed pull request.

Start free

Free tier, no credit card. Talk to sales at sales@tangigo.com.