Socrat AII

Discover what’s novel. Prove it. Protect it.

Comment

Socrat AII — Autonomous Invention Investigation Fleet Transforming engineering brain dumps into evidence-backed, counsel-ready patent packages.

Inspiration

💡 Inspiration Every year, billions of dollars in enterprise intellectual property evaporate unnoticed. An engineer pushes a breakthrough distributed reconciliation algorithm at 2:00 AM, benchmarks a 43% latency improvement, merges the pull request, and moves on to the next sprint.

The traditional Invention Disclosure Form (IDF) workflow is fundamentally broken:

The Recognition Gap: Companies rely on engineers self-diagnosing "I just built something patentable." Engineers are builders, not patent attorneys; they rarely recognize the patentable novelty in their own daily problem-solving. The Documentation Barrier: Engineers dread filling out dense, 20-page legal disclosure questionnaires. The Evidence Fragmentation: Supporting technical proof is scattered across Git commits, pull requests, Jira epics, benchmark logs, and design documents. The Legal Bottleneck: In-house patent counsel spends months playing "email ping-pong" chasing basic architecture diagrams, benchmark verification, and prior-art distinctions. We asked a foundational question: What if an enterprise didn't wait for disclosures, but autonomously detected inventive signals, conducted adaptive Socratic interviews with engineers, gathered technical artifacts, battled its own assumptions with an adversarial "devil's advocate" agent, and prepared a fortified, evidence-backed Invention Readiness Package for human legal review?

That vision inspired Socrat AII.

What it does

Socrat AII is an enterprise-grade autonomous agent fleet that orchestrates the entire invention discovery and verification lifecycle:

                      [ Synthetic Enterprise Signals ]
                 (GitHub PRs, Commits, Jira Epics, Benchmarks)
                                     │
                                     ▼
                         ┌───────────────────────┐
                         │    Invention Radar    │
                         │ (Signal Score Filter) │
                         └──────────┬────────────┘
                                     │
                                     ▼
                         ┌───────────────────────┐
                         │   Socratic Partner    │ ◄───► [ Engineer / Inventor ]
                         │  (Adaptive Interview) │
                         └──────────┬────────────┘
                                     │ Structured Invention Model
                                     ▼
                  ┌──────────────────────────────────────┐
                  │    Durable Taskmaster Orchestrator   │
                  └──────────────────┬───────────────────┘
     ┌───────────────────┬───────────┴───────────┬───────────────────┐
     ▼                   ▼                       ▼                   ▼

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Evidence Agent │ │ Prior-Art Agent │ │ Product Agent │ │Compliance Agent │ │(Git/Jira/Bench) │ │(Semantic arXiv) │ │(Roadmap Align) │ │ (PII / Secrets) │ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │ │ │ │ └───────────────────┼───────────────────────┴───────────────────┘ │ ▼ ┌───────────────────────┐ │ Challenge Agent │ ◄── [ Adversarial Counter-Analysis ] │ (Devil's Advocate) │ └──────────┬────────────┘ │ ▼ ┌───────────────────────┐ │ Patent Scribe │ │ (Ready-to-Review) │ └──────────┬────────────┘ │ ▼ ┌───────────────────────┐ │ Human IP Checkpoint │ ◄───► [ IP Counsel / Patent Attorney ] │ (1-Click Disposition) │ └───────────────────────┘

Key Capabilities: Autonomous Invention Radar: Ingests synthetic enterprise webhooks (PRs, commit diffs, benchmark metrics) to identify latent inventive activity. Adaptive Socratic Dialogue: An interactive conversational partner that dynamically queries the engineer across 5 core dimensions (Problem, Prior Solutions, Technical Mechanism, Novel Elements, and Empirical Impact) until uncertainty is minimized. Evidence Harvesting Graph: Automatically binds abstract claims to concrete code references (repository, file, commit SHA, and benchmark runs). Hybrid Semantic Prior-Art Engine: Queries scientific corpora (such as arXiv) and patent databases using Gemini Embedding (R1536 R1536 vector space), computing cosine distance and executing LLM-based re-ranking. Adversarial Challenge Agent: A dedicated "Devil's Advocate" agent that attempts to disprove the invention's novelty, identifying prior-art overlaps and technical ambiguities before filing. Enterprise Governance & Security Sandbox: Employs zero-leakage policies, PII anonymization, and credential scrubbing before data reaches external models. Persistent Multi-Week Execution: Employs Firestore Checkpointing allowing long-running tasks to hibernate, await human feedback, and resume seamlessly without state loss.

How Socrat AII Perfectly Fits All Three Hackathon Tracks Socrat AII was engineered from its inception to break the mold of simple single-turn LLM wrappers. Below is the comprehensive architectural and functional mapping demonstrating how Socrat AII directly fulfills and exceeds the criteria for Taskmaster, Collaborative Partner, and Fortified Enterprise Fleet.

                              ┌─────────────────────────────────────────────────────────┐
                              │                       SOCRAT AII                        │
                              │         Autonomous Invention Investigation Fleet        │
                              └────────────────────────────┬────────────────────────────┘
                                                           │
     ┌─────────────────────────────────────────────────────┼─────────────────────────────────────────────────────┐
     ▼                                                     ▼                                                     ▼

╔═══════════════════════════╗ ╔═══════════════════════════╗ ╔═══════════════════════════╗ ║ TASKMASTER ║ ║ COLLABORATIVE PARTNER ║ ║ FORTIFIED ENTERPRISE FLEET║ ║ End-to-End Orchestration ║ ║ Adaptive Socratic Dialogue║ ║ Institutional Governance ║ ╚═══════════════════════════╝ ╚═══════════════════════════╝ ╚═══════════════════════════╝ • Ingests messy enterprise data • Leads interview step-by-step • Central Agent Registry & SemVer • Executes parallel task DAGs • Dynamically probes missing info • Firestore Checkpoint Runtime • Scans live arXiv & GitHub • Maintains Understanding Matrix • Zero-Trust Agent Identities • Runs Adversarial Challenge Agent • Continuously captures feedback • Model Armor (PII/Secret Scrub) • Compiles 15-section IP Dossier • Builds living Invention Model • OpenTelemetry Audit Records

  1. ⚙️ Fit for Track 1: TASKMASTER "Build a complete workflow, not just a chatbot. Don't just make an agent that writes text. Make one that takes action. Find a messy, multi-step chore... handles the details, sends the right info to the right places, and proves it can do the heavy lifting."

📌 The Messy Enterprise Chore In modern technology companies, patent harvesting is a chaotic, multi-month chore:

Engineers build novel architectures, merge PRs, and forget to document them. In-house patent counsel spends weeks hunting down commits, benchmarking data, and Jira tickets. Prior-art search requires hours of manual querying across patent databases and scientific literature. Cross-functional alignment (Product roadmap relevance, Export compliance, Security sign-off) stalls in endless email chains. 🛠️ How Socrat AII Takes Real Action (Not Just Text Generation) Socrat AII replaces this entire manual nightmare with an autonomous 6-Stage Task Graph (DAG) executed by the Taskmaster Orchestrator:

[Invention Signal Detected] │ ▼ ┌────────────────────────────────────────────────────────────────────────────────────────┐ │ TASKMASTER ORCHESTRATOR PIPELINE │ ├────────────────────────────────────────────────────────────────────────────────────────┤ │ 1. [Evidence Agent] ➔ Scans GitHub PRs/Commits, parses ASTs, verifies benchmarks │ │ 2. [Prior-Art Agent] ➔ Generates 1536-D embeddings, queries live arXiv REST API │ │ 3. [Challenge Agent] ➔ Runs contrarian stress-test to uncover overlaps/flaws │ │ 4. [Product Agent] ➔ Matches mechanism against Jira epics & strategic roadmaps │ │ 5. [Compliance Agent] ➔ Enforces data sanitization, scans for leaked PII & secrets │ │ 6. [Patent Scribe] ➔ Synthesizes 15-section audit-backed Invention Package │ └────────────────────────────────────────────────────────────────────────────────────────┘ │ ▼ [Human Legal Review Checkpoint] Automated Evidence Harvesting: Scans Git repositories, matches commit SHAs (ConflictPredictor.ts), links benchmark metrics (43% latency improvement), and binds them directly to specific patent claims. Live Hybrid Literature Retrieval: Formulates multi-vector queries, queries the live arXiv API, computes cosine similarities in R 1536 space, and executes Gemini-powered re-ranking. Adversarial Self-Critique: Rather than blindly agreeing with the user, the Challenge Agent actively tries to disprove the invention's novelty by locating conflicting prior art. Executable Output Generation: Synthesizes all empirical data into an audit-tracked, counsel-ready Invention Readiness Package complete with technical diagrams, claims scopes, and prior-art risk tiers.

  1. 🤝 Fit for Track 2: COLLABORATIVE PARTNER "Build an agent that leads the way and takes notes. It should ask clarifying questions, guide the user step-by-step, and have a clear way to capture feedback, so it constantly adapts to the user's unique way of thinking."

🧠 Leading the Way: Adaptive Socratic Interviewing Instead of confronting the inventor with an intimidating 20-page blank legal form, the Socratic Discovery Agent acts as an intellectually curious, expert co-pilot:

[Engineer] ──"I made our cache sync faster."──► [Socratic Agent] │ ▼ [Calculates Entropy H(U)] [Finds Dimension Gap: Mechanism] │ ▼ [Engineer] ◄──"What changed algorithmically"───────────┘ "to avoid full sync broadcasts?" One Question at a Time: It never overwhelms the user. It asks exactly one focused, high-leverage question at a time to drill into the exact missing technical aspect.

📝 Dynamic Note-Taking & Living Invention Model As the engineer talks in conversational, unformatted engineering jargon, the Socratic Agent continuously extracts, refines, and structures the data into a Living Invention Model JSON:

Automatically structures problems, technical mechanisms, and novel elements. Visualizes real-time confidence meters on the inventor's dashboard. Captures user corrections and feedback instantly, re-evaluating the model dynamically without losing context.

  1. 🛡️ Fit for Track 3: FORTIFIED ENTERPRISE FLEET "Build a scalable network of institutional agents that hook into official enterprise infrastructure... cataloged for cross-department use... safely maintain context across weeks of asynchronous operations... interact with production data without violating enterprise compliance, data sovereignty, or security policies."

Socrat AII implements the complete four-pillar architecture required for enterprise fleet deployment:

┌────────────────────────────────────────────────────────────────────────────────────────────────┐ │ FORTIFIED ENTERPRISE ARCHITECTURE │ ├────────────────────────────────┬───────────────────────────────┬───────────────────────────────┤ │ 1. DISCOVERY & LIFECYCLE │ 2. CORE EXECUTION & STATE │ 3. SECURITY & GOVERNANCE │ ├────────────────────────────────┼───────────────────────────────┼───────────────────────────────┤ │ • Central Agent Registry │ • Asynchronous Agent Runtime │ • Zero-Trust Agent Identities │ │ • SemVer Versioning │ • Firestore Checkpoint Engine │ • Unified Agent Gateway │ │ • Defined Capability Contracts │ • 3-Tier Memory Bank │ • Model Armor Inline Guard │ │ • Cross-Department Discovery │ • Resilient Workflow Pause │ • PII & Secret Redaction Pass │ └────────────────────────────────┴───────────────────────────────┴───────────────────────────────┘ │ ▼ ┌───────────────────────────────┐ │ 4. TELEMETRY & OBSERVABILITY│ ├───────────────────────────────┤ │ • OpenTelemetry-Compliant Logs│ │ • Immutable DB Audit Records │ │ • Step-by-Step Chain Tracing │ └───────────────────────────────┘ A. Discovery & Lifecycle: Central Agent Registry Socrat AII catalogs all specialist agents in an official enterprise Agent Registry:

Cataloged Fleet: Socratic Discovery Partner (v1.4) — Conversational inventor elicitation. Taskmaster Orchestrator (v2.0) — Asynchronous DAG workflow coordinator. Evidence Agent (v1.2) — Code repository & benchmark harvesting. Prior-Art Agent (v2.1) — Vector embedding & arXiv literature search. Challenge Agent (v1.0) — Adversarial counter-analysis & novelty critique. Product Alignment Agent (v1.3) — Roadmap relevance & strategic evaluation. Compliance & Security Agent (v1.1) — Data boundary enforcement & sanitization. Patent Scribe (v1.5) — Legal disclosure document compiler. Strict Interface Contracts: Every registered agent defines explicit input/output schemas, required authorization roles, and SemVer lifecycle states (ACTIVE, DEPRECATED, RETIRED). B. Core Execution & State: Agent Runtime & Memory Bank Real enterprise IP reviews take days or weeks (e.g., waiting for an engineer to answer a prior-art clarification). Socrat AII solves this with:

Durable Firestore Checkpointing: When an agent finishes a step or requires human input, the execution state is saved to Firestore: json

{ "invention_id": "INV-00427", "current_step": "challenge", "completed_steps": ["evidence", "prior_art"], "pending_steps": ["challenge", "product", "compliance", "scribe"], "retry_count": 0, "last_checkpoint": "2026-09-01T04:30:00Z" } Zero State Loss: If a backend worker container restarts, scales to zero, or hibernates for 3 weeks, the Taskmaster instantly loads the checkpoint and resumes execution from the exact interrupted state without duplicate processing (Idempotent Execution). Three-Tier Memory Bank: Short-term Working Memory: Active reasoning context for current agent tasks. Investigation Memory: The aggregated Evidence Graph, interview transcript, and prior-art comparisons for a specific disclosure. Enterprise Memory: Approved patents, trade-secret definitions, and historical company prior art stored in PostgreSQL + pgvector for cross-organizational reuse. C. Security & Governance: Identity, Gateway & Model Armor Enterprise data sovereignty is strictly protected before any data leaves the perimeter:

Agent Identity: Every agent operates under a cryptographic zero-trust identity (e.g., agent://prior-art/v2.1), restricting its accessible tools and data boundaries. Unified Agent Gateway: All tool executions pass through the Agent Gateway, preventing unauthorized cross-domain access (e.g., the Prior-Art Agent can search public arXiv, but is explicitly denied access to customer databases or internal master credentials). Model Armor (Inline Security Guardrails): Automated PII Redaction: Strips employee personal identifiable information before sending prompts to reasoning models. Secret & Key Scrubber: Scans commit diffs and benchmark logs for tokens, private keys, or passwords, ensuring proprietary secrets are never leaked to external endpoints. Prompt Injection Defense: Sanitizes external research papers and untrusted metadata to prevent indirect prompt injection attacks against downstream agents. D. Telemetry: Observability & Immutable Audit Trail Legal compliance requires an unimpeachable record of every automated action:

OpenTelemetry-Compliant Tracing: Every agent execution captures parent trace IDs, duration, model token counts, and input/output payloads. Enterprise AuditLog System of Record: Every critical transition (agent trigger, prior-art match, challenge finding, human IP approval) is committed as an immutable database log: python

log = AuditLog( actor="Challenge Agent", action="Completed adversarial evaluation against prior-art references", source="Challenge Agent Engine", status="COMPLETED", approved_by="[email protected]" ) Human-in-the-Loop Verification: Legal decisions remain strictly human decisions. The fleet prepares verified evidence, but requires formal digital sign-off from IP counsel before any final filing package is locked. 🎯 Summary Matrix: Alignment at a Glance Track / Capability Hackathon Requirement Socrat AII Implementation & Proof Taskmaster Complete multi-step workflow with real heavy lifting Autonomous 6-stage DAG: code extraction, arXiv literature search, adversarial critique, and patent package drafting. Collaborative Partner Leads the way, asks questions, takes notes, adapts Socratic dialogue engine with Understanding Matrix U U, entropy minimization, and live Invention Model updates. Fleet: Discovery Central repository & versioning Formal Agent Registry managing 8 specialist agents with SemVer versions, capability schemas, and RBAC permissions. Fleet: Execution Long-running asynchronous execution Durable Firestore Checkpointing supporting pause-and-resume workflows across days/weeks with zero state loss. Fleet: Memory Cross-session context persistence Three-Tier Memory Bank (Task Memory → → Investigation Graph → → Enterprise Vector Store). Fleet: Security Zero-trust access & guardrails Agent Identity, Policy Gateway, and Model Armor (PII masking, secret scrubbing, prompt injection guards). Fleet: Telemetry OpenTelemetry observability & auditability Full reasoning chain tracing and immutable database Audit Logs for every agent action and human decision.

How we built it

How We Built It Socrat AII was engineered from the ground up as a resilient, multi-tiered enterprise application:

Tech Stack & Architecture Language Models & AI Framework: Google Gemini 2.0 / 1.5 Flash & Pro via Google GenAI SDK and custom Google ADK (Agent Development Kit) fleet orchestration primitives. Backend API & Taskmaster: FastAPI (Python 3.11) with asynchronous execution pipelines, SQLModel/SQLAlchemy ORM, and Pydantic v2 data contracts. Database & Vector Search: PostgreSQL 16 + pgvector with cosine distance vector indexes (1536 1536-dim). Built-in zero-configuration development fallback to SQLite with in-memory vector math. Durable Checkpointing: Firestore Checkpoint Service storing task graphs, completed/pending steps, and DAG states for zero-data-loss container restarts. External Integration Services: Live arXiv REST API client for dynamic literature search, alongside synthetic GitHub and Jira event listeners. Frontend & Control Center: Next.js 14 (App Router), React 18, TailwindCSS, and Lucide Icons, featuring live agent activity streams, Socratic conversational UI, interactive prior-art maps, and an instant Corporate Identity Switcher. Deployment & Cloud: Dockerized multi-stage container deployments targeting Google Cloud Run

Challenges we ran into

Challenges We Faced Combating LLM Sycophancy & Confirmation Bias:

Challenge: Standard LLMs tend to be agreeable, frequently validating the user's claims and overestimating invention novelty. Solution: We built an adversarial Challenge Agent with an explicit contrarian system prompt and independent reasoning budget, dedicated entirely to finding counter-examples, claim overlap, and prior-art similarities. Durable Asynchronous State Across Long Horizons:

Challenge: Enterprise IP reviews take days or weeks. If a backend worker dies or a container spins down while awaiting inventor clarification, active agent memory cannot be lost. Solution: We implemented an immutable checkpointing engine in Firestore. Every transition in the agent DAG updates completed and pending task lists, allowing any worker instance to resume execution seamlessly. Hallucination-Proof Prior-Art Mapping:

Challenge: Generating fabricated patent citations or hallucinated academic DOIs is disastrous for legal compliance. Solution: We implemented a strict Two-Tier Search Strategy: the Prior-Art Agent generates search vectors, retrieves real documents via the live arXiv API, calculates mathematical cosine similarity against actual paper abstracts, and passes verified hits to a Gemini Re-Ranker. Enterprise Privacy & Data Leaks:

Challenge: Confidential source code and production secrets must never leak into unvetted public prompts. Solution: Our Compliance & Security Agent runs local redaction passes, scrubbing PII, tokens, and proprietary trade secrets before prompt dispatch.

Accomplishments that we're proud of

Accomplishments We're Proud Of The Socratic Interview Engine: Engineers can articulate their work naturally in conversational prose, while the backend continuously populates a formal 15-point structured patent disclosure. The Adversarial Agent Debate: Watching the Prior-Art Agent and Challenge Agent stress-test technical claims in real-time brings unprecedented rigor to AI-assisted IP analysis. Sub-Second Hybrid Search & Vector Reranking: Combining pgvector vector distances with full-text keyword matching and LLM re-ranking achieves remarkable prior-art precision. Seamless Multi-Persona UX: A built-in role switcher enables users to experience the platform as an Inventor (Sarah Chen), IP Counsel (Alex Vance), Security Officer (Sophia Sec), or Product Manager.

What we learned

What We Learned Adversarial agent architectures produce vastly superior enterprise outputs. Giving agents distinct, competing objectives (e.g., Builder vs. Devil's Advocate) eliminates the blind optimism typical of single-agent pipelines. Human-in-the-loop is not a limitation—it's the core product requirement. AI agents should not attempt to file patents autonomously; their greatest value lies in preparing rigorously investigated, audit-backed packages that empower human counsel to make decisions 10 × 10× faster. Durable checkpointing is mandatory for real-world enterprise fleets. Stateless agents are demos; stateful, checkpointed agent fleets that survive container restarts are production software.

What's next for Socrat AII

What's Next for Socrat AII Direct Patent Office Integrations: Direct USPTO PAIR and EPO Open Patent Services (OPS) connectors for live patent citation graphs. Zero-Touch Enterprise Webhooks: Native GitHub App and Slack bot integrations that passively monitor pull requests and alerting channels for instant invention detection. Graph RAG on Enterprise Codebases: AST-level semantic parsing across entire code repositories to automatically map patent claims to individual functions, classes, and architectural components. Automated Defensive Publications: One-click generation and publishing of defensive disclosures to preempt competitor claims when a full patent application is not pursued.

Built With

Share this project:

Updates

Submission history