Equinox Agentic Platform

Project Overview

• Name: Equinox Agentic Platform
• Type: Standalone, multi-tenant agentic AI platform with its own builder/management UI (closed-source, proprietary to Infosys Equinox)
• Context: A self-contained product for Infosys Equinox: a runtime and studio where business users discover, build, configure, run, schedule, and share AI agents and multi-step workflows.
• Purpose: Give non-engineers a complete, agentic AI workbench - backed by a graph-based multi-agent runtime - while keeping every tenant's data, credentials, and agents fully isolated.

My Role

I designed and built this platform end to end, from scratch, as the sole builder - both the backend runtime and orchestration service and the front-end studio UI. There were no co-authors. Every layer described below is mine: the FastAPI runtime and its feature modules, the LangGraph-based agent engine, the multi-tenant data model, the agent and workflow lifecycle, the streaming chat surface, the personalised dashboard pipeline, and the Next.js studio application that drives all of it.

On the UI side I built the agentic studio application (the agents, workflows, and management screens) on top of the shared Equinox design-system and API libraries; the application, its screens, and its integration layer are mine.

Key Capabilities

Agent building and management

• Agent definitions with name, description, status, tenancy scope, and trigger type (manual, scheduled, chat, event). Two execution shapes: graph agents interpreted by the engine, and simpler tool-using agents (system prompt plus tools).
• Workflows - long-running, multi-step processes, optionally on a cron schedule, that can pause and resume at human-in-the-loop steps.
• Agent store / marketplace - a discoverable catalog with trending, popular, new, by-type, and my-subscriptions views; install, uninstall, clone-and-edit, and preview actions. Subscribing links a tenant to a published agent without copying it; cloning copies and decouples future updates.
• My Agents - manage installed and authored agents, surface failed and interrupted runs, and edit, clone, or delete them.

Agent runtime and orchestration

• Graph orchestration - compiles graph definitions (nodes, edges, state schema) into runnable multi-agent graphs, with tool binding, guardrail attachment, and memory wiring.
• Compiled-graph cache - process-local plus distributed cache keyed by tenant and agent, pre-warmed at startup so first-request latency stays low and evicted on edit.
• Prebuilt orchestrator agents - ready-made agents (an admin assistant, a workflow builder, a domain shopping assistant) that ship with the platform and use its tool catalog.
• Sandboxed code execution - agents can run code in isolated per-run workspaces, kept separate from the platform process.
• Tool integration via MCP - external tool providers are registered, their catalogs discovered and cached, and the runtime consults them when an agent chooses a tool. An n8n bridge lets agents trigger external automation flows.
• Long-term memory - a persistent semantic store agents read from and write to across conversations, backed by vector search.
• Guardrails - content-safety policies attached per agent or per workflow, with violations logged for review.
• Knowledge bases - retrieval-augmented generation over chunked, embedded documents with vector search.
• Reusable prompts and skills - parameterised, versioned prompts with variable interpolation, plus a reusable skills library agents can compose.
• A2A protocol - agent-to-agent communication for cooperating multi-agent systems.

Streaming chat

• Streams responses over Server-Sent Events and WebSockets with live GitHub-flavored markdown rendering.
• Live activity trace - shows tool calls and intermediate steps as the agent works, plus a todo/task tracker that surfaces the agent's plan, collapsible once the answer lands.
• Interrupts - when a workflow pauses for a choice, selectable options render inline and resume the run on selection.
• Conversation history with grouping, soft-delete, and per-user ownership.

Personalised dashboard

• A JSON-spec-driven bento grid of typed tiles (KPI, chart, table, callout).
• Built by a background multi-agent pipeline that summarises raw signal, prioritises it, and composes a validated spec using a validate-and-retry loop against the spec schema.
• Designed as eager background precompute plus a cache-read request path - no LLM call on the page-load hot path - with a polling fallback and a static placeholder so the surface is never blank on a cold cache.

Architecture (high level)

• Backend - a single async FastAPI service organised into self-contained feature modules (agents, graph engine, workflows, orchestrators, knowledge bases, MCPs, memory, guardrails, prompts, skills, sharing, threads, stores, users, A2A, LLM providers, logs). Each module owns its router, service, repository, and schemas, layered over shared base-repository, base-service, dependency, and middleware classes.
• Agent runtime - LangChain plus LangGraph for graph-based orchestration, a LiteLLM gateway abstraction over multiple model providers, LangGraph checkpointing for durable graph state, and the pre-warmed compiled-graph cache.
• Multi-tenancy - every persistent record is scoped by tenant (store within a business). Request dependencies enforce session and tenant context so data cannot leak across tenants.
• Scheduling - background schedulers backed by a persistent MongoDB job store run scheduled agents and drive the recurring dashboard rebuild; jobs survive restarts.
• Studio UI - a Next.js App Router application with a consistent server-component-plus-client-view split per page, built on the internal Equinox design system over MUI, with React Query for data and an i18n-ready (next-intl) routing layer.
• Observability - distributed tracing across every agent step and tool call (OpenTelemetry plus a custom Langfuse-tracing package), structured event logging queryable through an admin log explorer, and APM instrumentation.
• Lifecycle - a startup sequence connects datastores, initialises crypto for encrypted per-tenant credentials, warms the MCP tool catalog and graph cache, starts the schedulers, and runs idempotent seeders and migrations.

Frontend (the studio UI)

• Routing - locale- and tenant-scoped routes (business and store in the path), with dedicated areas for agents (list, create, detail, chat), workflows (list, create, detail, chat, execution history), and management (guardrails, knowledge bases, LLM providers, MCP, prompts, skills) plus per-store settings.
• Agent builder - forms to define agents, attach tools, guardrails, knowledge, and memory, and choose trigger types.
• Workflow builder and visualisation - a BPMN-style visual editor plus a graph visualiser and stage tracker that render the running workflow, with an inline chat surface for human-in-the-loop steps.
• Chat experience - streaming responses, a markdown renderer with code and mermaid-diagram support, a JSON viewer for structured tool output, and a live todo tracker.
• Data layer - TanStack React Query hooks over a typed, domain-driven API client (endpoint builders, fetch-option formatters, and TypeScript contracts per domain).

Technical Stack

Backend

• Framework: FastAPI (async, Pydantic v2), Uvicorn ASGI, Python 3.11+
• Agents: LangChain plus LangGraph (graph orchestration, checkpointing, prebuilt and swarm helpers)
• LLM gateway: LiteLLM provider abstraction (Anthropic, OpenAI, Bedrock, Vertex, and more)
• Data: MongoDB (document model and vector search via Motor/PyMongo) for agents, workflows, threads, tenants, plus RAG and memory vectors
• Cache: Redis for the MCP tool catalog and compiled-graph cache
• Scheduling: APScheduler with a persistent MongoDB job store
• Automation bridge: n8n client for external workflow triggers
• Observability: OpenTelemetry plus a custom Langfuse-tracing package; APM instrumentation
• Security: symmetric encryption for stored per-tenant provider credentials, session-based auth, role-based access control
• Packaging / run: Docker and Docker Compose (MongoDB, Redis, backend), an environment-aware launcher with self-signed-cert generation for local HTTPS

Frontend

• Framework: Next.js (App Router), React 19, TypeScript
• UI: internal Equinox design system over MUI, with BPMN, datagrid/datatable, forms, and rich-text editor libraries
• Data: TanStack React Query
• i18n: next-intl (i18n-ready routing)
• Chat rendering: react-markdown with GitHub-flavored markdown and mermaid diagrams, over Server-Sent Events and WebSockets
• Charts: Chart.js; drag-and-drop via react-dnd
• Build / quality: pnpm workspaces plus Turborepo, Jest, SonarQube, Prettier

This writeup intentionally describes the platform at a high level. Source code, internal endpoints, hostnames, infrastructure identifiers, and proprietary pipeline details are omitted to protect Infosys Equinox intellectual property.