Gigan — AI Infrastructure Intelligence Platform

AI-native infrastructure investigation, replay, and operation in isolated AWS-compatible sandboxes.

Workbench | Quick start | Model providers | Architecture | Agent flow | Development

Gigan turns a problem statement or Terraform project into a disposable cloud environment that can be inspected, changed, validated, and replayed. It combines Strands Agents, the Floci AWS emulator, an interactive operations workbench, and a durable PostgreSQL event store.

Note

Gigan works with emulated infrastructure. It does not provision resources in your production AWS account. AWS behavior and service coverage are limited by the configured emulator.

What Gigan Does

• Scenario-aware provisioning: translates infrastructure problems into dependency-aware resource plans instead of deploying one fixed stack.
• Bounded agent loops: uses Strands maker/checker loops to plan, act, observe, and verify a goal within explicit attempt and timeout budgets.
• Pluggable model runtime: uses Gemini by default, with explicit opt-in support for LM Studio, Unsloth Studio, and other OpenAI-compatible endpoints.
• Live operations: combines the dependency canvas, agent console, AWS CLI, resource-scoped actions, and EC2 Session Manager in one Operate workspace.
• Visual infrastructure: renders topology, dependencies, inventory, and resource metadata in one workspace.
• Evidence-led investigation: turns agent actions, CLI output, resource state, hypotheses, and proposed fixes into durable investigation records.
• Kubernetes investigation: discovers EKS-backed workloads and provides resource inspection, pod logs and shells, rollout operations, scaling, and manifest import.
• Terraform round trips: imports a folder or .zip, hands ambiguous HCL to a parser sub-agent, and exports the current sandbox as modular Terraform.
• User-isolated sessions: scopes workspaces, history, resources, events, and memories to authenticated accounts.
• Durable sessions: persists resources, agent memory, CLI and kubectl output, lifecycle activity, and investigation state in PostgreSQL.
• Replay and resume: opens an archived session as a snapshot or recreates it in a fresh sandbox for continued work.
• Central runtime control: delegates sandbox and backing-container lifecycle operations to an authenticated internal control-plane service.
• AgentOps telemetry: traces agent workflows through AgentOps with prompt and tool content redacted by default.

Workflow

1. Sign in to an isolated workspace.
2. Describe a failure or target architecture, or import a Terraform project.
3. Gigan asks the infrastructure planner for a bounded resource graph.
4. The control plane provisions that graph in an isolated Floci runtime.
5. Operate the environment through the canvas, agent, AWS CLI, kubectl, or an emulated EC2 shell while Gigan retains the resulting evidence.
6. Analyze hypotheses, draft controlled fixes, capture snapshots, replay the environment, and run explicit validation checks.
7. Pause a session to release its runtime, resume it into freshly recreated infrastructure, or export Terraform and the investigation report.

Workbench

Operate

Operate is the primary session view. It keeps the dependency graph, inventory, Terraform controls, resource details, session state, and live runtime status in one workspace.

Agent and Runtime Console

The agent and runtime console remain visible together so the user can compare the agent's reasoning with the exact AWS CLI, kubectl, or EC2 shell evidence produced by its tools.

Resource-Scoped EC2 Session

Selecting an EC2 node opens its AWS-style resource view. The Login tab runs bounded commands in that instance's backing container and records the output against both the resource and investigation.

Investigate

The investigation workspace separates retained evidence, AI-generated hypotheses, and controlled fix plans. This keeps diagnosis reviewable before a mutation is approved or applied.

Replay and Validation

Snapshots establish a reproducible baseline. Replay visualizes infrastructure drift, while Validate evaluates explicit checks and retains confidence and validation history.

Quick Start

Prerequisites

• Docker Desktop or Docker Engine with Compose v2
• A Gemini API key for the default agent setup, or a supported local model server
• Ports 5173, 8000, 5433, and the sandbox ports beginning at 4566 available locally

1. Configure the environment

cp backend/.env.example backend/.env
cp frontend/.env.example frontend/.env

The default provider is Gemini. Set its API key in backend/.env:

GEMINI_API_KEY=your-gemini-api-key

AGENT_PROVIDER_TYPE does not need to be set. When it is absent, Gigan uses Gemini with gemini-2.5-flash, preserving the original runtime behavior. The checked-in environment template sets AGENT_PROVIDER_TYPE=gemini explicitly for readability, which has the same result.

Without a Gemini key, deterministic scenario planning remains available, but LLM-backed planning, parser recovery, and agent conversations are limited.

2. Start the stack

docker compose up --build

The backend applies Alembic migrations automatically before starting. Source directories are mounted into the containers, so backend and frontend changes reload during development.

Service	URL
Gigan application	http://localhost:5173
FastAPI service	http://localhost:8000
OpenAPI docs	http://localhost:8000/docs
Health endpoint	http://localhost:8000/api/health

Stop the stack without deleting session data:

docker compose down

To remove the PostgreSQL volume as well:

docker compose down -v

Model Providers

Gigan constructs all model clients through one Strands provider adapter. Gemini is the default and requires no provider selector. Local and custom providers are activated only when AGENT_PROVIDER_TYPE is explicitly changed.

Provider	Selection	Model resolution	Authentication
Gemini	unset or gemini	AGENT_MODEL, defaulting to gemini-2.5-flash	GEMINI_API_KEY or GOOGLE_API_KEY
OpenAI-compatible	custom	Explicit AGENT_MODEL is required	Optional AGENT_CUSTOM_API_KEY
Unsloth Studio	unsloth	AGENT_MODEL, or the active model discovered from /v1/status	AGENT_USERNAME and AGENT_PASSWORD

Selecting custom or unsloth never silently routes the request to Gemini. A missing endpoint, model, or credential is returned as a provider configuration error so prompts are not sent to an unintended service.

LM Studio

1. Load a tool-capable model in LM Studio.
2. Start its OpenAI-compatible local server, normally on port 1234.
3. Read the exact model ID from LM Studio or from:

curl http://127.0.0.1:1234/v1/models

When Gigan runs through Docker Compose, configure backend/.env with the host address exposed to the backend container:

AGENT_PROVIDER_TYPE=custom
AGENT_MODEL=your-loaded-model-id
AGENT_BASE_URL=http://host.docker.internal:1234/v1
AGENT_CUSTOM_API_KEY=

When the FastAPI backend runs directly on the host, use the loopback address:

AGENT_PROVIDER_TYPE=custom
AGENT_MODEL=your-loaded-model-id
AGENT_BASE_URL=http://127.0.0.1:1234/v1

Unsloth Studio

Gigan authenticates with the Unsloth Studio API and uses its bearer token for the OpenAI-compatible model endpoint. Leave AGENT_MODEL empty to discover the currently active model, or set it to pin a specific loaded model.

AGENT_PROVIDER_TYPE=unsloth
AGENT_MODEL=
AGENT_BASE_URL=http://host.docker.internal:8888
AGENT_USERNAME=unsloth
AGENT_PASSWORD=your-unsloth-password
AGENT_PROVIDER_TIMEOUT_SECONDS=30

Use http://127.0.0.1:8888 instead when the backend runs directly on the host. The Unsloth base URL may include /v1; Gigan normalizes it before calling the login and status endpoints.

Other OpenAI-Compatible Endpoints

The custom provider also supports authenticated remote services, vLLM, and other servers implementing the OpenAI chat-completions contract:

AGENT_PROVIDER_TYPE=custom
AGENT_MODEL=provider-model-id
AGENT_BASE_URL=https://models.example.com/v1
AGENT_CUSTOM_API_KEY=provider-api-key

The model should support tool calling, sufficiently large prompts and tool results, and reliable structured JSON output. A text-only model may answer basic questions but cannot reliably provision, investigate, or mutate infrastructure.

Apply and Verify

Compose reads provider settings when the backend container is created. Recreate that service after changing backend/.env:

docker compose up -d --force-recreate backend

Then probe the selected provider through Gigan:

curl "http://localhost:8000/api/agent?probe=true"

The response reports the selected provider, model, redacted configuration, and probe result. It never includes model passwords or full API keys.

Common local-provider failures:

Symptom	Check
Custom model is not configured	Set an exact AGENT_MODEL for custom
Connection refused from Docker	Start the model server and use host.docker.internal, not 127.0.0.1
Unsloth reports no active model	Load a model in Unsloth or set AGENT_MODEL
Tool calls appear as plain text	Use a model/template with OpenAI-compatible tool calling
Old provider remains active	Recreate the backend container after editing backend/.env

Architecture

Gigan separates the browser-facing application from privileged container control. The FastAPI application owns authentication, orchestration, policy, and persistence; the internal control plane is the only service with Docker socket access.

Runtime Boundaries

Layer	Responsibility
React + TypeScript	Session creation, topology, consoles, evidence, replay, validation
FastAPI	Authentication, session orchestration, commands, resource actions, investigation APIs
Gigan control plane	Starts, reconciles, health-checks, and removes session runtimes and backing containers
Strands Agents	Provider-neutral planning, parallel specialist orchestration, tool use, goal checking
Floci	Disposable AWS-compatible runtime, EC2 backing containers, and EKS emulation
Kubernetes integration	Cluster discovery, kubectl execution, manifest import, and workload operations
PostgreSQL	Users, authentication sessions, durable workspaces, events, resources, and agent memories
AgentOps	workflow and model telemetry

Isolation and Trust Boundaries

• Browser requests authenticate through an HTTP-only session cookie. The authenticated user ID is bound to the request and applied to session repository operations.
• The browser never talks to Docker or a sandbox directly. AWS CLI, kubectl, shell, and resource actions pass through typed FastAPI endpoints and command policy checks.
• The backend calls the control plane through an internal URL and shared token. Only the control-plane container mounts /var/run/docker.sock.
• Every active session receives a distinct runtime assignment, endpoint, and resource graph. Pausing removes the runtime assignment while preserving its durable session state.
• Resuming starts a fresh runtime and replays the saved resource plan rather than trusting a stale endpoint from the previous container.

Durable State Model

PostgreSQL is the source of truth across browser refreshes and runtime recreation. sessions holds the current materialized workspace, while session_events retains append-only lifecycle, agent, CLI, kubectl, resource, and investigation activity. session_resources provides the latest resource inventory, and session_memories stores semantic, episodic, and procedural memory independently from any one model invocation.

Session Lifecycle

Agent Flow

Gigan uses one shared GiganAgent adapter around native Strands agents, but selects a different execution mode for each workload:

Workload	Strands mode	Result contract
Infrastructure planning	Schema-constrained completion	Catalog selection or validated custom resource graph
Terraform recovery	Schema-constrained parser sub-agent	Supported resources and logical dependencies
Parallel analysis	Strands graph with specialist nodes and synthesis	One evidence-backed combined result
Interactive operation	Bounded maker/checker GoalLoop with tools	Verified answer, attempts, stop reason, and metrics
Final response	Tool-free synthesis agent	Concise Markdown grounded in retained tool evidence

Each native Strands runtime is fresh for one invocation. Cross-request conversation, resources, commands, and memories are restored from PostgreSQL, which prevents a model process from becoming the hidden source of session state.

Infrastructure Creation

The planner cannot pass arbitrary commands directly to the host. Custom plans are restricted to supported resource types, normalized into a dependency graph, and translated into backend-owned AWS CLI templates. Resource IDs are captured from real emulator responses and used to configure downstream dependencies.

Interactive Investigation Loop

The checker passes mutation goals only when both the change and a subsequent verification are present in tool output. Inspection goals require concrete runtime evidence. Failed actions can trigger another materially different attempt, but the loop is bounded by AGENT_GOAL_MAX_ATTEMPTS, AGENT_GOAL_TIMEOUT_SECONDS, tool-round limits, and the overall execution timeout.

Tools, Guardrails, and Observability

• inspect_session_state resolves ambiguous targets from the current resource graph instead of relying on IDs from model memory.
• run_aws_cli strips endpoint concerns from the model, rejects unsupported shell syntax, and executes against only the selected sandbox.
• run_ec2_shell targets a specific backing container and requires an instance ID when the session contains multiple EC2 resources.
• run_kubectl applies a guarded command policy and requires post-mutation workload verification.
• Lifecycle hooks capture model, graph, tool, error, token, and timing telemetry. AgentOps export is enabled and content capture remains disabled by default.
• The final synthesis step cannot turn an unverified action into success; it receives the goal status and retained evidence and must preserve remaining blockers.

Infrastructure Coverage

The infrastructure planner and Terraform importer currently understand:

VPC, subnet, internet gateway, NAT gateway, route table, route-table association, flow log, security group, EC2, S3, SQS, RDS, IAM role, EKS cluster, target group, load balancer, listener, and VPC peering.

Built-in scenario plans cover common investigations such as:

• EC2 to RDS connectivity
• Two-VPC connectivity and peering faults
• Three-tier VPC, ALB, EC2, and RDS deployments
• EKS control-plane and Kubernetes workload investigations
• Cross-account-style S3 policy testing
• Lambda to SQS permission failures

Resource Operations

Every supported resource can expose a live inspection action. Specialized operations currently include:

Resource	Operations
EC2	Inspect, Session Manager shell, reboot, stop, start
VPC	Inspect, route tables
S3	Inspect, list objects, object metadata, bucket policy
SQS	Inspect, send message, receive messages
EKS	Inspect cluster and network metadata, refresh Kubernetes inventory
Kubernetes pod	Describe, current/previous logs, shell, restart
Kubernetes deployment/stateful set	Describe, rollout status, restart, undo, scale
Kubernetes service	Describe and inspect selected endpoints
Other Kubernetes objects	Describe live state and recent events
RDS, IAM, Lambda, ELBv2 resources	Live provider inspection

EC2 Investigation Example

Open an EC2 node from the topology, select Login, and run bounded Linux commands inside its backing container. A useful read-only first pass is:

uname -a
cat /etc/os-release
uptime
whoami && id
hostname && hostname -I
df -h
free -h
ps aux --sort=-%cpu | head -15
ip addr
ip route
ss -lntup
cat /etc/resolv.conf

Each command, output, exit code, and resource association is retained as investigation evidence. Tool availability depends on the selected instance image.

Terraform

The deterministic Terraform parser recognizes:

aws_vpc, aws_subnet, aws_internet_gateway, aws_nat_gateway, aws_route_table, aws_route_table_association, aws_flow_log, aws_security_group, aws_instance, aws_s3_bucket, aws_sqs_queue, aws_db_instance, aws_eks_cluster, and aws_iam_role.

Unrecognized or ambiguous resource blocks are passed to the Terraform parser sub-agent when a live model is configured. Export produces a modular layout for network, compute, storage, messaging, and IAM resources.

Session Data

Gigan stores account and runtime state in six normalized tables:

Table	Purpose
users	Account identity and password credentials
auth_sessions	Expiring, hashed browser-session credentials
sessions	Session metadata, counters, status, and materialized state
session_events	Append-only agent, CLI, resource, and lifecycle activity
session_resources	Latest materialized resource inventory
session_memories	Semantic, episodic, and procedural agent memory

Pausing tears down the active Floci and backing-container runtime while retaining the database record. An archived or paused session can be opened without starting infrastructure; resuming asks the control plane to recreate supported resources and continues with the saved conversation and investigation context.

GCP Deployment

The production backend deployment targets Google Compute Engine, not Cloud Run. Gigan needs Docker socket access so the control plane can create Floci runtimes and EC2/EKS backing containers. The frontend can stay on Vercel and call the GCP-hosted API.

Terraform provisions:

• a dedicated VPC and subnet
• firewall rules for SSH and the temporary backend HTTP port
• a reserved static external IP
• a Compute Engine VM running Ubuntu 24.04
• a VM service account with logging and monitoring permissions

The VM startup script installs Docker, Docker Compose, Git, and supporting tools. GitHub Actions then deploys the backend over SSH, writes the runtime env files, runs docker-compose.prod.yml, and verifies /api/health.

GitHub Secrets

Fill the local github_run.sh and run it to push secrets into GitHub. github_run.sh is ignored by git.

Required secrets:

Secret	Purpose
GCP_PROJECT_ID	Existing GCP project ID
TF_STATE_BUCKET	GCS bucket name used for Terraform state
GCP_REGION / GCP_ZONE	GCP placement, defaults to asia-south1 / asia-south1-a
GCP_SSH_USERNAME	SSH user for GitHub Actions, defaults to gigan
GCP_SSH_PUBLIC_KEY / SSH_PRIVATE_KEY	Deploy key pair for the VM
POSTGRES_PASSWORD	Production Postgres password
GIGAN_CONTROL_PLANE_TOKEN	Shared backend/control-plane token
GEMINI_API_KEY	Live Strands/Gemini agent credential
CORS_ORIGINS	Exact Vercel frontend origin(s)

GCP authentication can use either Workload Identity Federation:

Secret	Purpose
GCP_WORKLOAD_IDENTITY_PROVIDER	Full Workload Identity provider resource
GCP_SERVICE_ACCOUNT	Deploy service-account email

Or a bootstrap service-account JSON key:

Secret	Purpose
GCP_CREDENTIALS_JSON	Service-account key JSON for Terraform and gcloud

Optional deployment secrets:

Secret	Purpose
TF_MACHINE_TYPE	Defaults to e2-standard-2
TF_BOOT_DISK_SIZE_GB	Defaults to 50
TF_SSH_ALLOWED_CIDRS	JSON list; restrict this outside quick bootstrap
TF_APP_ALLOWED_CIDRS	JSON list allowed to reach temporary backend port 8000

GCP Role Requirements

The GitHub deploy identity should have these roles on the target project:

Role	Why it is needed
roles/serviceusage.serviceUsageAdmin	Enable required project APIs
roles/storage.admin	Create and update the Terraform state bucket
roles/compute.admin	Create the VPC, firewall rules, IP address, and VM
roles/iam.serviceAccountAdmin	Create the VM service account
roles/iam.serviceAccountUser	Attach the service account to the VM
roles/resourcemanager.projectIamAdmin	Grant logging and monitoring roles to the VM service account

Deploy

$EDITOR github_run.sh
./github_run.sh

Then push to main or run Deploy Backend to GCP manually from GitHub Actions. The workflow bootstraps the GCS state bucket, runs Terraform, deploys the containers, and verifies /api/health.

Before DNS and TLS are configured, the backend is reachable on the temporary VM URL:

http://<vm-static-ip>:8000

After you add your own HTTPS endpoint, point Vercel's VITE_API_URL to that API URL and set AUTH_COOKIE_SAMESITE=none plus AUTH_COOKIE_SECURE=true.

Configuration

Configuration is loaded from backend/.env and frontend/.env.

Variable	Default	Description
DATABASE_URL	PostgreSQL on db:5432	Async SQLAlchemy connection URL
CORS_ORIGINS	http://localhost:5173	Comma-separated browser origins
AUTH_SESSION_DAYS	14	Browser authentication lifetime
AUTH_ALLOW_REGISTRATION	true	Enable self-service local registration
AUTH_COOKIE_SAMESITE	lax	Browser cookie same-site policy
AUTH_COOKIE_SECURE	production-aware	Force secure cookies, useful for Vercel-to-GCP auth
AGENT_PROVIDER_TYPE	gemini	Provider selector: gemini, custom, or unsloth; optional for Gemini
GEMINI_API_KEY	empty	Gemini credential used only by the gemini provider
GOOGLE_API_KEY	empty	Alternative environment name for the Gemini credential
AGENT_MODEL	gemini-2.5-flash	Gemini model, required custom model ID, or optional Unsloth override
AGENT_BASE_URL	empty	Required OpenAI-compatible or Unsloth endpoint URL
AGENT_CUSTOM_API_KEY	empty	Optional bearer key used only by a custom endpoint
AGENT_USERNAME / AGENT_PASSWORD	empty	Required Unsloth Studio login credentials
AGENT_PROVIDER_TIMEOUT_SECONDS	30	Custom and Unsloth HTTP timeout
AGENT_MAX_STRANDS	4	Maximum parallel specialist agents
AGENT_MAX_TOOL_ROUNDS	4	Tool-loop budget for one invocation
AGENT_GOAL_MAX_ATTEMPTS	3	Maker/checker iteration budget
AGENT_GOAL_TIMEOUT_SECONDS	150	Goal-loop timeout
AGENT_EXECUTION_TIMEOUT_SECONDS	600	End-to-end agent timeout
GIGAN_INFRA_AGENT_LLM	1	Enable LLM infrastructure planning
GIGAN_SANDBOX_PROVIDER	floci	Infrastructure emulator provider
GIGAN_SANDBOX_NETWORK	gigan-sandbox	Docker network for sandbox runtimes
GIGAN_CONTROL_PLANE_URL	Compose service URL	Internal runtime-control endpoint
GIGAN_CONTROL_PLANE_TOKEN	local development token	Shared backend/control-plane credential
GIGAN_KUBECTL_BIN	/usr/local/bin/kubectl	kubectl binary used for cluster actions
AGENTOPS_ENABLED	false	Enable AgentOps export
AGENTOPS_API_KEY	empty	AgentOps project key
AGENTOPS_CAPTURE_CONTENT	false	Export prompt, output, and tool content
VITE_API_URL	http://localhost:8000	Vite development proxy target

See backend/.env.example and frontend/.env.example for the complete defaults.

API

The development server exposes interactive OpenAPI documentation at /docs. Core endpoints include:

Method	Endpoint	Purpose
POST	/api/auth/login	Create an authenticated browser session
POST	/api/auth/register	Create an isolated user workspace
POST	/api/session/	Create and provision a session
GET	/api/session/status	Read active or selected session state
POST	/api/session/chat/	Run an agent goal loop
POST	/api/session/command/	Execute an AWS CLI or EC2 shell command
POST	/api/session/kubernetes/refresh	Refresh the Kubernetes inventory
POST	/api/session/kubernetes/manifests/import	Apply imported Kubernetes manifests
POST	/api/session/resource-actions/run	Execute a typed resource action
GET	/api/session/history	List durable session history
POST	/api/session/resume/{id}	Recreate an archived session
POST	/api/session/pause/{id}	Release a session runtime but retain its state
DELETE	/api/session/{id}	Remove the runtime and durable session record
GET	/api/session/{id}/investigation	Read investigation state
POST	/api/session/{id}/investigation/analyze	Generate evidence-backed hypotheses
POST	/api/session/{id}/investigation/validate	Validate the current hypothesis
POST	/api/session/{id}/fix-plans	Draft an explicit infrastructure change set
POST	/api/session/terraform/import	Import a Terraform folder or archive
GET	/api/session/terraform/export	Export modular Terraform

Development

Backend

Requires Python 3.12, uv, PostgreSQL, and a reachable Docker daemon.

docker compose up -d db
cd backend
cp .env.example .env

When running the backend outside Compose, change the database address in backend/.env from db:5432 to localhost:5433, then run:

uv sync --extra dev
uv run alembic upgrade head
GIGAN_RELOAD=1 uv run uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

Frontend

Requires Node.js 20 or newer.

cd frontend
cp .env.example .env
npm ci
npm run dev

Checks

# Backend
cd backend
uv run --extra dev ruff check .
uv run --extra dev pytest -q

# Frontend
cd frontend
npm run lint
npm run build
npm run test:runtime

The Playwright runtime suite expects the Vite application to be available at http://localhost:5173.

Project Structure

Gigan/
|-- backend/
|   |-- app/
|   |   |-- agentic/            # Strands agent, prompts, tools, telemetry
|   |   |-- auth/               # User context and authentication security
|   |   |-- api/                # FastAPI routes and request schemas
|   |   |-- control_plane/      # Central Docker and sandbox lifecycle service
|   |   |-- db/                 # SQLAlchemy models and persistence
|   |   `-- services/           # Sessions, resources, Kubernetes, Terraform
|   |-- migrations/             # Alembic schema migrations
|   `-- tests/                  # Backend unit and integration tests
|-- frontend/
|   |-- src/
|   |   |-- components/         # Workbench, topology, consoles, operations
|   |   |-- hooks/              # Durable session workspace state
|   |   |-- pages/              # Landing, dashboard, and history
|   |   `-- styles/             # Application style layers
|   `-- gigan-runtime.spec.js    # Playwright workflow regressions
|-- artifacts/                  # Product tour and repeatable recording script
|-- docs/assets/                # README media
|-- terraform/                  # GCP backend infrastructure
|-- docker-compose.prod.yml     # Production backend, DB, and control plane
`-- docker-compose.yml          # Local development stack

Security

Caution

The internal control-plane service mounts /var/run/docker.sock so it can create and control Floci, EKS, and EC2 backing containers. Docker socket access is effectively host-level control. Run Gigan only on a trusted development machine.

• Do not expose the development stack directly to the public internet.
• Replace the default control-plane token and demonstration password outside local development.
• Keep API keys in local .env files and never commit them.
• Review agent-generated commands before using Gigan with any provider other than an isolated emulator.
• AgentOps content capture is disabled by default. Enable it only when exported prompts, responses, and tool payloads are acceptable for your environment.

Contributing

1. Create a focused branch.
2. Keep backend and frontend changes within their existing module boundaries.
3. Add tests for behavioral changes.
4. Run the backend and frontend checks before opening a pull request.

Bug reports and focused proposals are welcome through GitHub Issues.

Built With

Gigan was scaffolded from CodeStash Starterpack, a FastAPI + React + PostgreSQL + Terraform starter kit with a built-in agent generator. The FastAPI/SQLAlchemy backend layout, React + Vite frontend, Docker Compose stack, Terraform modules, and CI workflow all originate from that template.

License

Gigan is available under the MIT License.