Understanding Syntera's Agent Architecture

The Manager is the entry point for every interaction. When you send a message, the Manager classifies it, validates security, and routes it to the right handler.

• • Classifies incoming messages (new project, GitHub import, follow-up)
• • Validates requests against security policies
• • Initializes GitHub issue context and metadata
• • Creates isolated sessions for new projects
• • Sets up Langfuse tracing for observability

User Message
  │
  ├─ prepare-session (tracing, user resolution)
  ├─ initialize-github-issue (context loading)
  ├─ validate-security (AI-powered scanning)
  ├─ classify-message (route determination)
  │
  ├─── new-session → Create project session
  ├─── start-planner → Route to Planner Graph
  └─── no-op → Already handled

The Manager also handles configuration passthrough, injecting GitHub tokens, API keys, project metadata, and custom rules into every child graph invocation.

Once the Manager routes a request, the Planner takes over. Its job is to understand your codebase, generate requirements documents, and produce an implementation plan you can approve before any code is written.

• • Initializes the cloud sandbox and clones your repository
• • Generates a Business Requirements Document (BRD)
• • Generates a System Requirements Specification (SRS)
• • Produces a step-by-step implementation plan
• • Waits for your approval before proceeding

Planner Workflow
  │
  ├─ prepare-graph-state
  ├─ initialize-sandbox (Daytona cloud env)
  ├─ generate-brd-srs (requirements)
  ├─ [user approval checkpoint]
  ├─ generate-plan (ordered tasks)
  ├─ notetaker (summarize)
  ├─ interrupt-proposed-plan
  └─ [user approval → start programmer]

The Planner uses intelligent caching - sandbox initialization uses a 10-minute cache, plan generation uses 5-minute, and user approval nodes are never cached. This balances speed with freshness.

The Programmer is where code gets written. Syntera uses two specialized DeepAgent variants depending on the task type:

• • New Project DeepAgent - creates applications from scratch with full scaffolding
• • GitHub Import DeepAgent - modifies existing repositories with codebase awareness

Both variants use specialized subagents for different aspects of development:

New Project Subagents:
  ├─ Frontend Specialist (React, TypeScript, Tailwind)
  ├─ Backend Specialist (Node, Python, PostgreSQL)
  ├─ DevOps Specialist (Docker, CI/CD)
  ├─ UI Enhancer (visual polish)
  ├─ Error Diagnoser (runtime issues)
  └─ Code Reviewer (quality checks)

GitHub Import Subagents (19+):
  ├─ Code Analyzer, Bug Fixer, Feature Implementer
  ├─ Test Writer, Refactorer, Security Auditor
  ├─ Documentation Writer, Infrastructure Architect
  └─ CI/CD Specialist, Monitoring Specialist, ...

After every file write, the Programmer automatically runs Prettier for formatting and ESLint for linting, ensuring consistent code quality without manual intervention.

Syntera's agents have access to a rich set of tools that let them interact with the sandbox environment:

• • Shell - execute commands with security filtering
• • Filesystem - read, write, and edit files with automatic linting
• • Git - version control operations, branching, committing
• • Grep - search file contents across the codebase
• • PostgreSQL - database operations and schema management
• • URL Content - fetch documentation and web resources
• • Diagram Generator - create Mermaid diagrams for architecture docs

All shell commands pass through a security filter that blocks dangerous patterns like destructive file operations, system-level commands, and untrusted script execution.

The entire system is built on LangGraph's state management. Each graph maintains typed state using Zod schemas with specialized reducers:

// Core state shared across all graphs
interface GraphState {
  messages: BaseMessage[];        // Conversation history
  sandboxSessionId: string;       // Cloud environment ID
  targetRepository: TargetRepository;
  branchName: string;             // Git branch
  codebaseTree: string;           // Directory structure
  taskPlan: TaskPlan;             // Execution plan
  tokenData: ModelTokenData[];    // Usage tracking
  customRules: CustomRules;       // User config
}

State flows from Manager to Planner to Programmer, with each graph extending the base state with its own fields. Task plans, token usage, and sandbox sessions persist across the entire lifecycle.

Syntera's multi-agent architecture means each part of your request is handled by a specialist. The Manager coordinates, the Planner designs, and the Programmer executes - with human approval at every critical checkpoint. Understanding this flow helps you write better requests and know when to intervene for the best results.