Magnivonic

The organizational intelligence layer for the enterprise: reasoning across Revenue, Operations, Customer Success, and Security as one connected organization—not four.

Comment

Built for **H0: Hack the Zero Stack with Vercel v0 and AWS Databases, under the **Monetizable B2B Enterprise App* track.*

Inspiration

Every team in a company is competent inside its own walls and blind to every other team's screen. Revenue watches renewals. Security watches access logs. Support watches tickets. Engineering watches delivery. The most expensive problems in any organization live between these teams — a security anomaly, a support spike, a falling health score, and an imminent renewal on the same account aren't four separate tickets, they're one cascading event. At small scale a good operator stitches this together by hand. At enterprise scale it's impossible, and that gap is exactly where churn, breaches, and missed expansion hide. I wanted to build the system that watches the whole business at once, the way a chief of staff would.

What It Does

Magnivonic is an organizational intelligence layer: specialized domain agents — Revenue, Operations, Customer, and Security — read their part of the business in parallel, continuously. A Chief of Staff agent aggregates what they found. A General Manager agent reasons across the unified picture and emits typed executive decisions — each classified as exactly a Risk, Opportunity, Coordination Gap, or Drift — with a recommended action, a real computed confidence, the cross-domain evidence behind it, and a precedent recalled from the organization's own memory.

The product opens already connected, deliberately. Magnivonic begins by validating its configured organizational connections before launching its multi-agent reasoning pipeline. Rather than asking users to upload files, it is designed to reason over the systems organizations already use.

In the seeded demo scenario, this turns four disconnected signals — a security access anomaly, a support ticket spike, a falling health score, and a renewal due in 18 days, all on the same account — into one connected finding instead of four separate alerts nobody linked. Ask the platform anything in plain language and it answers with its evidence shown first, then reads the answer back aloud.

How I Built It

A two-tier multi-agent system on a fully serverless AWS stack, deployed on Vercel.

  • Specialized domain agents (AWS Lambda, Python 3.12) — Revenue, Operations (reading the real GitHub API), Customer, and a deliberately deterministic Security agent, each producing structured evidence with a real computed score.
  • Chief of Staff (Lambda) — fires all specialized domain agents in parallel and aggregates them into one unified context package with a severity-weighted combined confidence.
  • General Manager (Lambda + Amazon Bedrock Nova Pro) — reasons across the package, retrieves precedents from organizational memory, classifies and emits 1–4 typed executive decisions, computes confidence in code, writes results to Aurora, and fires a Slack alert.
  • Memory — Aurora PostgreSQL Serverless v2 with pgvector, one managed store holding both the relational facts and a 1024-dimensional vector index behind the organizational memory table, so a decision and the precedent it cites are never out of sync.
  • Voice — a dedicated speech endpoint converts a Debrief answer to speech via Amazon Polly (neural) — a genuine second output modality, since Nova Pro is multimodal on input only.
  • API surface — Amazon API Gateway with nine REST endpoints; Secrets Manager for every credential; EventBridge for background events.
  • Frontend — Next.js 16 on Vercel: a public marketing site (built with v0) and a login-gated live platform that talks only to the real AWS endpoints — no mock data anywhere in the product.

Why Aurora PostgreSQL + pgvector

Aurora PostgreSQL Serverless v2 with pgvector is the architectural foundation of Magnivonic's organizational memory. Cross-domain reasoning needs two things from one place: the relational facts and semantic recall over past incidents. Aurora Serverless v2 with pgvector does both in a single managed engine — the organizational memory table stores 1024-dimensional embeddings behind an HNSW index, sitting in the same transactional store as the customers, deals, and risks tables it cites. A decision and the precedent behind it can never go out of sync, because there is no second system to keep in sync. The HNSW index enables efficient approximate nearest-neighbor retrieval as organizational memory grows, and Aurora Serverless v2 autoscales compute on demand with every agent run.

Why Nova Pro

The reasoning pipeline runs on Amazon Bedrock Nova Pro, a first-party model available across every AWS account type and region. An early plan to use a third-party model hit a regional access restriction on this account; Nova Pro's first-party status removed that risk entirely. Nova Pro is multimodal on input, but does not synthesize audio — which is exactly why voice output is a deliberate, separate Amazon Polly call rather than an invented model capability.

Every number is defensible. Every real score's formula is printed directly in the product, on a dedicated Confidence page:

$$ \text{security_score} = \min!\left(1.0,\ 0.35 \cdot \text{anomaly} + \text{API-spike tier} + 0.10 \cdot \text{off-hours} + \text{export tier} + \text{failed-auth tier} + \text{unusual-IP tier}\right) $$

$$ \text{revenue_risk} = 0.40 \cdot \text{renewal-urgency} + 0.30 \cdot \text{health-gap} + 0.15\,(1-\text{close-prob}) + 0.15 \cdot \text{neg-sentiment} $$

$$ \text{GM confidence} = \max!\left(0.30,\ 0.5 \cdot \text{breadth} + 0.5 \cdot \text{severity-weighted-strength}\right) $$

Amazon Nova Pro narrates every one of these computed values. It never invents the number.

Why This Is Built to Be Monetized

  • The buyer already exists. Per-seat to the people who stitch this picture together by hand today — a Chief of Staff, a Head of RevOps, a VP Engineering, a Head of Customer Success or Security.
  • Land-and-expand is architectural. Each specialized domain agent is independent behind one orchestration layer, so a new connector is pure expansion revenue, not a re-platform.
  • The unit economics are built to work from seat one. Every layer — Lambda, Aurora Serverless v2, Bedrock — scales to zero and bills on demand, so there's no fixed infrastructure floor to cover before a single customer is profitable.
  • The moat compounds by design. A competitor can copy a screen in a weekend. They cannot copy an organization's own incident history accumulating in its recall layer — every additional analysis run adds to a memory store a brand-new competitor starts without.
  • Horizontal by design. The same engine that watches a SaaS company's renewal pipeline can watch a hospital's cross-departmental risk or a public agency's service signals — one core platform, no rebuild per vertical.

Challenges I Ran Into

  • A region restriction forced a model decision mid-build. The original reasoning model hit an AISPL region block on this AWS account type. The entire pipeline moved to Nova Pro — a first-party Bedrock model with no such restriction.
  • A silent dimension mismatch, caught before it shipped. Titan Embed V2 returns 1024-dimensional vectors, not the 1536 initially provisioned — caught at the first real embed call, not discovered later as a production incident.
  • Cold start hit a hard account ceiling, and I documented it instead of hiding it. The analysis endpoint runs at roughly 8 seconds warm; eliminating the cold start entirely required Provisioned Concurrency, which hit this AWS account's Lambda concurrent-executions quota — AWS reserves the entire quota as the unreserved floor, leaving zero headroom to provision even one instance. The fix is a Service Quotas increase, not an architecture change.
  • The hardest call: defending the numbers. Several scores started as LLM-estimated percentages dressed up as precise confidence. Revenue, Customer, and the General Manager's confidence were rebuilt as real formulas computed in code, with Nova Pro narrating, not inventing.

What I Learned

  • Defend every number, or don't show it. Moving scores from LLM output to real code formulas is what makes the product credible the moment a technical buyer asks "where did this come from."
  • Pick the boring, correct store. Aurora + pgvector doing both relational and vector work in one engine removed an entire class of cross-store consistency bugs before they could exist.
  • Know when not to use an LLM. Security stays deterministic because security findings must be auditable, not probabilistic.

What's Next

  • Voice input via Amazon Transcribe (microphone → Transcribe → the existing Nova Pro flow) — scoped, deliberately not built this round.
  • Image evidence using Nova Pro's real image-understanding on seeded dashboard screenshots.
  • Additional enterprise connectors (CRM, ticketing, identity, observability, and collaboration platforms) to expand cross-domain organizational reasoning.
  • Deeper per-team scoping and adaptive memory recall as an organization's own history grows.

Built With

  • amazon-aurora
  • amazon-bedrock
  • amazon-polly
  • aws-api-gateway
  • aws-eventbridge
  • aws-iam
  • aws-lambda
  • aws-secrets-manager
  • framer-motion
  • github-api
  • nextjs
  • pgvector
  • postgresql
  • python
  • slack
  • tailwindcss
  • typescript
  • v0
  • vercel
Share this project:

Updates