DOCSEARCHbyAlgolia
Submit Docs

Tembo Documentation

website·Indexed 36 days ago

https://tembo.io/docs

An agent-native engineering automation platform designed for automated pull requests, code generation, and developer workflow integration. Documentation covers CI/CD pipeline integration, secure code execution, governance and human-in-the-loop controls, auditing, and enterprise identity management.

Tokens
5.8K
Snippets
3
Records
42
Agent score
73%

What's inside Tembo

  1. Overview of Tembo's Autonomous Engineering Automation

    Tembo is an agent-native engineering automation platform designed for production-grade workflows. It links monitoring, issue tracking, and code repositories to multi-agent code generation. Key capabilities include:

    • Autonomous PR Generation: Converts tickets (e.g., from Linear or Jira) and monitoring alerts (e.g., from Sentry) into Pull Requests with staged review workflows.
    • Runtime Validation via MCP: Uses Model Context Protocol (MCP) servers to allow agents to call external tools such as Playwright tests, databases, and observability endpoints during the reasoning process to validate fixes.
    • Multi-Repo Orchestration: Supports coordinated PR creation across multiple repositories through automation templates or SDK calls.
    • Feedback Loop: Converts PR review comments into iterative automated updates to the code.
    • Programmatic Control: Provides a typed SDK and public API for embedding automations directly into CI/CD pipelines.

  2. Overview of Tembo Engineering Automation Platform

    Tembo is an agent-native engineering automation platform designed to autonomously detect issues, triage incidents, and open coordinated pull requests (PRs) across multiple repositories. It connects to version control, issue trackers, error monitoring, databases, and collaboration tools. Key capabilities include:

    • Automations: Supports scheduled, event-driven, and manual automations authored in natural language (e.g., Sentry alerts triggering PRs).
    • Multi-Repo Coordination: A single automation task can open coordinated PRs across different repositories and platforms to support cross-service fixes.
    • Runtime Tooling (MCP): Uses the Model Context Protocol (MCP) to allow agents to invoke external tools (tests, databases, observability systems) during their reasoning process to ensure safer, higher-context code changes.
    • Human-in-the-Loop: Features a 'Feedback Loop' where PR review comments and tagging @Tembo trigger iterative agent updates and PR revisions.

  3. Secure automation execution using Tembo sandboxes

    Tembo executes automations within isolated sandboxed environments using container or VM-level isolation, restricted networking, and controlled process capabilities to limit the blast radius of execution. To ensure deterministic execution and binary provenance, the platform supports Nix flake environment manifests and provides curated, preinstalled toolchains in sandbox images to minimize the need for downloading arbitrary binaries at runtime.

  4. Manage and select coding agents for automation tasks in Tembo

    Tembo supports a multi-agent architecture allowing the use of various coding agents (such as Claude Code, Codex/GPT, Cursor, Amp, and OpenCode) at the organization, project, or task level. To optimize for cost and capability, assign routine automations to faster, lower-latency models and reserve complex debugging tasks for higher-capability agents.

    Key features for agent management include:

    • Model Routing & MAX Mode: Use the CLI MAX mode to run multiple models in parallel to compare candidate patches and select the most robust change set based on tests and heuristic scoring.
    • Staged Pipelines: Implement a pipeline where an initial agent generates changes, a verification stage runs sandbox tests, and a final agent handles polishing and documentation via task chaining.
    • Traceability: Agent decision logs and intermediate outputs are streamed to the dashboard for review and export.
    • Performance Monitoring: Track agent effectiveness using metrics such as average token consumption, cloud VM runtime, time to first passing test, and reviewer acceptance rate via Tembo's usage reporting and task logs.

  5. Manage secrets and credentials in Tembo automations

    Secrets and credentials are provisioned into sandboxes via secure secret injection mechanisms to avoid embedding sensitive data in code. Tembo maintains a least-privilege model where audit logs record which secrets were referenced by an automation run without exposing the actual secret values in user-facing logs.

  6. Implement autonomous PR workflows with Tembo

    Tembo allows developers to automate the transition from a detected issue to a proposed fix. This is achieved through:

    1. Event-Driven Automations: Triggering PR creation based on monitoring alerts or issue tracker updates.
    2. Runtime Tooling: Integrating MCP servers so agents can interact with the production context (databases, observability) and run validation tools (Playwright) before submitting a PR.
    3. Multi-Repo Coordination: Using the SDK or automation templates to create matching branches and PRs across several repositories simultaneously.
    4. CI/CD Integration: Using the typed SDK and API to operationalize these automations within existing deployment pipelines.

  7. Manage automated agent behavior and governance in Tembo

    Tembo ensures automated agent changes are subject to human review by presenting outputs as pull requests (PRs) that must be reviewed, approved, or rejected via Git provider UIs, Slack, or issue tracker integrations. Governance is enforced through repository and organization-level defaults, allowing teams to specify the agent or model used for a specific repo and apply consistent automation policies across codebases. For enterprise environments, Tembo provides Single Sign-On (SSO), Role-Based Access Control (RBAC) for administrative and reviewer roles, and detailed audit logging that tracks automation triggers, agent identity, sandbox logs, and test artifacts.

  10. Verify machine-authored changes with signed commits

    To ensure verifiable provenance for changes authored by agents, Tembo supports signed commits attributed to service accounts. This allows SCM (Source Control Management) history to maintain a verifiable record of machine-authored changes. Verification can be automated in CI by fetching signed commit metadata and cross-referencing agent task IDs against archived logs using the Tembo SDK.

  11. Deploy Tembo Enterprise on customer infrastructure

    Tembo Enterprise supports self-hosted deployments on customer-managed infrastructure using Docker and Kubernetes. This allows the platform to operate within a customer's VPC, ensuring that operational security teams can validate and control network ingress, egress policies, and connector endpoints. Deployment is managed via Helm charts.
    helm install tembo ./charts/tembo -f values.yaml

  12. Integrate Tembo programmatically using the SDK and CLI

    Tembo can be integrated into CI pipelines and developer tools via a public API, a typed TypeScript SDK, and a CLI. This allows for the programmatic creation of tasks, retrieval of logs, and orchestration of automations. The SDK is recommended for automation orchestration, while the CLI is suited for ad hoc developer invocations or triggering background tasks during pull request pipelines and nightly maintenance jobs.
    # Install the Tembo TypeScript SDK
npm install @tembo-io/sdk