HorizonOps AI

HorizonOps AI is a local decision-support prototype built with Python, FastAPI, Streamlit, Docker, and Azure AI Foundry. Independent specialist services analyze one objective in parallel; an orchestrator validates their structured outputs and produces a single decision dossier.

It takes a business or product objective, runs it through specialist agents, and returns a decision dossier, an execution board, and traceable outputs.

In one line: give HorizonOps AI a strategic goal and it turns it into risks, options, priorities, next actions, and a clear go / pivot / stop decision.

The project is intentionally scoped as a portfolio-ready local system. It demonstrates A2A 1.0 service orchestration, structured LLM outputs, deterministic validation checks, document ingestion, trace persistence, and an Azure-backed inference path. It is not presented as a production decision system.

What It Does

Given an objective such as:

Launch an AI micro-agency for automating workflows in independent Italian restaurants.
Objective: secure 3 paying pilot clients in 30 days.

HorizonOps AI returns:

• a strategic decision dossier
• opportunity and risk analysis
• financial and viability review
• board-style critique
• 5 concrete next actions
• a Kanban-style execution board
• quality gates
• structured JSON traces
• Markdown and JSON exports

See a captured sample output in docs/demo-output.md.

Why It Is Interesting

HorizonOps AI is built as a small network of local services instead of a single chat call:

• each specialist agent has a clear role
• outputs are parsed into structured JSON
• weak outputs can be retried or recovered
• the orchestrator synthesizes compact agent data
• every dossier is stored with trace metadata
• workspaces keep project history and execution tasks

Architecture

flowchart TD
    UI["Streamlit UI :8510"] -->|REST /dossier| ORCH["Orchestrator :11010"]
    EXT["External A2A client"] -->|A2A JSON-RPC| ORCH

    ORCH -->|A2A JSON-RPC| SIGNAL["Signal :11011"]
    ORCH -->|A2A JSON-RPC| RISK["Risk :11012"]
    ORCH -->|A2A JSON-RPC| STRATEGY["Strategy :11013"]
    ORCH -->|A2A JSON-RPC| EXEC["Execution :11014"]
    ORCH -->|A2A JSON-RPC| CRITIC["Critic :11015"]
    ORCH -->|A2A JSON-RPC| FINANCE["Finance :11016"]

    SIGNAL --> FOUNDRY["Azure AI Foundry"]
    RISK --> FOUNDRY
    STRATEGY --> FOUNDRY
    EXEC --> FOUNDRY
    CRITIC --> FOUNDRY
    FINANCE --> FOUNDRY

    ORCH --> DATA[("Local traces and workspaces")]

Loading

Agents

Agent	Role
Orchestrator Agent	Coordinates all agents and creates the final dossier
Signal Intelligence Agent	Finds market, customer, timing, and opportunity signals
Risk and Red-Team Agent	Stress-tests assumptions, risks, and kill criteria
Strategy Architect Agent	Builds positioning, options, tradeoffs, and milestones
Execution Planner Agent	Converts the strategy into concrete tasks and metrics
Board Critic Agent	Reviews weak logic, vague actions, and contradictions
Finance and Viability Agent	Checks pricing, costs, margins, and economic feasibility

A2A Protocol

Every service is exposed through the official a2a-sdk using the A2A 1.0 JSON-RPC binding. The orchestrator discovers each remote agent from its public Agent Card before delegating work.

• discovery: GET /.well-known/agent-card.json
• protocol endpoint: POST /a2a
• message transport: A2A SendMessage
• lifecycle: submitted task, working, then completed, failed, or canceled
• result transport: JSON artifact attached to the completed task
• task storage: SDK InMemoryTaskStore for the local single-instance demo

The SDK request handler also provides the standard task lookup, listing, and cancellation operations. Streaming and push notifications are explicitly advertised as unsupported instead of being simulated. The previous /message route remains available as a deprecated local compatibility endpoint.

Features

• A2A 1.0 orchestration with discoverable FastAPI agent services
• Official A2A Python SDK, JSON-RPC transport, tasks, states, and artifacts
• Streamlit command center
• Azure AI Foundry Responses API integration
• Structured Pydantic output schema
• JSON repair and fallback for imperfect model output
• Deterministic checks for completeness, schema integrity, sources, and service health
• Workspace-isolated memory and dossier history
• Kanban-style execution board
• Decision lenses: Founder, Consultant, Investor, Product Manager, Cloud Architect, Red Team
• Upload context files: .txt, .md, .csv, .json, .log, .pdf
• PDF text extraction with pypdf
• Markdown and JSON export
• Dockerfile included
• Unit tests included

Project Structure

.
|-- agents/                 # FastAPI specialist agent services
|-- core/                   # A2A, orchestration, contracts, prompts, memory, parsing
|-- ui/                     # Streamlit app
|-- config/                 # environment example and settings
|-- docs/                   # demo output and documentation assets
|-- tests/                  # unit tests
|-- main.py                 # starts all services and UI
|-- requirements.txt
|-- Dockerfile
`-- README.md

Setup

Use Python 3.10+.

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
Copy-Item config\.env.example .env

Update .env with your Azure AI Foundry values:

PROJECT_ENDPOINT=https://your-resource.services.ai.azure.com/api/projects/your-project
MODEL_DEPLOYMENT_NAME=gpt-4.1
SERVER_URL=localhost

You also need to be authenticated with Azure:

az login

Run Locally

python main.py

Open:

http://localhost:8510

Default ports:

Service	Port
Streamlit UI	8510
Orchestrator	11010
Signal Intelligence	11011
Risk and Red-Team	11012
Strategy Architect	11013
Execution Planner	11014
Board Critic	11015
Finance and Viability	11016

Try This Prompt

Launch an AI micro-agency for automating workflows in independent Italian restaurants.
Objective: secure 3 paying pilot clients in 30 days.

Constraints: 300 EUR budget, solo founder, Python/Azure/FastAPI/Streamlit skills,
0 current clients, local outreach in Italy, simple MVP, low delivery cost, and
clear stop/pivot criteria.

Recommended settings:

• Mode: deep
• Decision lens: Founder
• Horizon: 30 days
• Live research: off for a local demo without web search, on for source-backed analysis

Test

python -m unittest discover -s tests

The same test suite runs on Python 3.10, 3.11, and 3.12 through GitHub Actions.

Docker

docker build -t horizonops-ai .
docker run --env-file .env -p 8510:8510 -p 11010-11016:11010-11016 horizonops-ai

Offline Demo Mode

For deterministic local output without Azure calls:

HORIZONOPS_OFFLINE_MODE=true

Current Limitations

• PDF ingestion extracts selectable text only. Scanned PDFs require OCR first.
• Local memory uses JSON files, not a production database.
• File persistence is designed for a single local instance, not concurrent replicas.
• A2A task state is kept in memory and is lost when an individual service restarts.
• A2A streaming and push notifications are not enabled in this local version.
• Quality checks validate structure and minimum content depth; they do not prove that an AI recommendation is correct.
• API authentication, rate limiting, and multi-user isolation are outside the current local-demo scope.
• The local runner starts several processes on fixed ports.
• Azure deployment files are intentionally minimal; the Dockerfile is ready, but production IaC can be added later.

What This Shows

This project demonstrates:

• cloud-oriented Python service design
• standards-based A2A agent orchestration
• structured LLM output validation
• practical reliability patterns for model output
• Azure AI Foundry integration
• local developer experience and Docker readiness

License

MIT