SpeedHacks: The Official speedrun Hackathon #SFTechWeek

Rung

Rung is Gmail Priority Inbox for phone support. Never on hold. Never a stranger. THE PROBLEM Calling support means waiting on hold, then explaining everything from scratch to a rep who spends the first few minutes catching up. Both sides lose time, and the most urgent caller waits in the same line as everyone else. WHAT RUNG DOES - Nobody holds: an AI voice agent answers every call instantly on a real phone number. - The rep never starts cold: the agent writes a three-line brief (what happened, what they tried, what they want). - The right call first: every caller is ranked by urgency + money at stake + minutes waited, with a "why ranked here" reason. Waiting keeps adding points, so small issues are never stuck. - Never a stranger: Rung recognizes the caller's number, so the next call starts with "Hi Reid, I've got your details up." Memory is kept per company and never shared across companies. - A human calls back, most urgent first. Reps press "Take next" and never collide on the same caller. TIME AND MONEY SAVED (illustrative model) For a bank taking 1,000 calls a day: callers skip 380 hours of hold per day, and reps skip 1.5 minutes of catching up per call. A rep minute costs $0.62 and Rung costs $0.30 per AI minute, so the bank saves $10,000/month after paying for Rung. HOW WE USED PARTNER TECH- Dial: each company gets a Dial phone number and AI voice agent. Our Setup page publishes the agent'sing the call, Dial's agentcalls our MCP tools (lookup_caller, triage_call, save_profile) to recognize thecaller and file the brief.ength and transcript. Dialmeant we built no phone system and had real calls working the same day. - Keewano: every call sendames or phone numbers) toKeewano. The Insights tab asks Keewano for the day's trends: calls by urgency, returning callers, callbaclead dashboard withoutbuilding analytics. TRY IT Live site: Call the demo bank: +1 618 464 4253 STACK Dial, Keewano, Supabase (Peact, TypeScript, MCP,built with Claude Code.

DialKeewano

Recourse

polar bears

Automated insurance claims for consumers

DialKeewanoAlike

Align by Liminal

Liminal

AI agents execute at machine speed. Organizational alignment still happens at meeting speed. Align by Liminal connects company priorities, accountable human decisions, and running AI agents—so agents don't keep executing yesterday's plan after the organization changes direction. The problem: A CEO changes launch priorities. Product depends on Security, but Security's agent is still optimizing an outdated goal: closing tickets oldest first. Product can't change Security's commitments—and shouldn't be able to. Resolving the mismatch traditionally requires gathering evidence, proposing changes, negotiating constraints, updating the plan, and communicating the decision across tools. What Align does: 1. Surfaces the conflict: Align connects company goals, cross-team dependencies, and agent work to the current approved priorities. 2. Tests alternatives: Sparta Worlds evaluates competing execution plans using the same synthetic tickets and independent checks. 3. Preserves human authority: Product proposes a change; Security reviews and ratifies its own goal. Every decision is versioned and traceable. 4. Updates running agents: Relevant opted-in Claude Code sessions receive goal-change notifications. Agents retrieve the authorized plan through read-only MCP instead of deciding another team's priorities themselves. Our actual results: - Old plan: FAIL — 2/9 Sparta checks passed; a protected P0 security ticket was modified. - Corrected plan: PASS — 9/9 checks passed; the protected ticket remained untouched, including in an injected-outage test. - Live agent replanning: In a documented uninterrupted session, the agent recognized the CEO's changed priorities, held for Security's decision, and executed the revised plan after ratification—without another human prompt. Across repeated recorded runs, the throughput-first plan failed 8/8 times; the corrected plan passed 8/8 times. Time saved: The existing manual process is estimated at 200 minutes across five coordination steps. Align measures its own time to agreement and human decisions separately from sandbox preparation. These are prototype measurements, not claims of validated production savings. Who needs this: Product and engineering leaders at AI-native companies coordinating autonomous agents across teams with different goals. What's next: Bring authoritative goal context into agent preflight, Linear/Jira issue intake, and Slack collaboration—without replacing the tools teams already use. Built with: Sparta Worlds, Alike, TypeSafe/Jev, Claude Code, MCP, Next.js, TypeScript, and Vercel AI Gateway. Source and reproducible evidence: SpeedHacks 2026 prototype. Demonstrated using a synthetic company and independently graded sandbox execution; production organizational outcomes have not been verified.

SpartaAlikeNext.js 16+11

Axolotl

AI assistants fail or abandon tasks midway all the time. A tool call fails, the agent gives up asking for something it could've looked up, or hits a login wall, and then the task goes back to you. Right now, nearly every harness doesn't handle failure between agents, check their answers, or penalize poorly designed agents. What Axolotl does: Axolotl is an MCP server any assistant can call (ChatGPT, Claude Code, Codex) that uses Darwin to autonomously handle agent failure. When an agent gets stuck, Axolotl: 1. Figures out why: could it be missing info, a broken tool, or a login/payment wall? 2. Reprompts the main agent automatically: it looks up missing details itself, like turning a vague place name into a street address, or finding a replacement agent on Darwin. We have added safeguards to prevent this on sensitive tasks like payments. 3. Keeps going until task completion: failures are discarded and retried in alternate ways until it works. Adding the Axolotl MCP to your harness (e.g., Claude Code or Codex) or personal agent is super easy, and Axolotl gets automatically triggered when the assistant is stuck midway through a task. How we use Darwin: Axolotl uses Darwin to find replacement tools, connectors, and agents. Every Darwin result is screened first to avoid unsafe agents or agents that would ask for login info. We try free agents before paid ones, and paid ones only within a budget you set. Team: Swarchis Kulkarni, Devesh Aggarwal, Gautam Anand

DarwinNext.jsReact+2

alai

Winners

The AI Tutor That Knows Where You Went Wrong alai is an AI tutor that runs as a web app on an iPad. The student writes with an Apple Pencil, the way they already do homework, and taps Check. alai reads the handwritten work as the user works through the problem, not just the final answer, finds the exact step that went wrong, and gives one short nudge. It never hands over the answer or launches into a lecture. It keeps every student's mistakes, hints and self-corrections as an ordered history in Keewano.

KeewanoFramework: Next.js 16 (App Router) with React 19 and TypeScript Styling: Tailwind CSS v4 Canvas: tldraw 5the whiteboard students work on Tutor model: Claude through the Anthropic SDK+1

Intention

The Intention Company

Intention lets you say what you mean and writes it the way you would, everywhere you write. Everyone writes all day. Texts, Slack, email, notes, posts and docs. It takes forever, and AI help makes it worse because it never sounds like you. Hold a key, say a few words, and the finished message shows up right at your cursor in your own voice. Intention learns how you write from your own writing. Your greetings, how long you write, your tone with each person and how you sign off. A quick text to a friend comes out casual, and a reply to a client comes out like your best email. One key works in Messages, Slack, Gmail, Notes and anywhere else you type on your Mac. Saving time is just the start. The same 86 words take over 2 minutes to type and 36 seconds to say. The bigger win is never staring at a blank box again, never rewriting drafts that sound like a robot, and sounding like yourself everywhere you write. Everyone who writes could use this, and the model of you gets better with every message. It is a native Mac app built with SwiftUI and AppKit that listens while you hold a key and writes at your cursor, with streaming speech and a writer that learns from your own writing.

SwiftSwiftUIAppKit+6

R2M — Responsibility to Monitoring

R2M

Problem: Companies want to deploy AI agents that take real actions (restart services, scale, roll back deployments), and enterprises buying agents from vendors need proof those agents are controlled. Today there is no independent way for a customer's security team to approve what an agent may do, enforce it at runtime, and get evidence afterwards. Observability tools only show what happened; they don't stop the risky action.What R2M does: R2M is an AI governance and runtime-control platform. A vendor ships an agent with its policies written as code. The customer's security reviewer approves those exact policies (by hash). Before the agent can run any risky tool, it must ask R2M, which answers ALLOW, DENY or REQUIRE_APPROVAL. Risky actions need a human to approve that exact action, and R2M then issues a single-use, signed, 60-second grant bound to the exact arguments. The simulated infrastructure re-checks the grant, so a tool call that skips R2M is refused and raises a critical incident.How it works (live demo): OpsPilot, an AI operations agent built on OpenAI, monitors a payments service. When the service degrades, OpsPilot queries Keewano over MCP for which past fixes actually worked (based on recorded outcomes), proposes a rollback, and R2M blocks it until Meridian's security reviewer approves. After approval the rollback runs exactly once and is verified. Every step is recorded as traces, policy decisions, grants, token cost and tamper-evident (SHA-256) evidence.Also included: a release gate (a build can't act until its evals pass, its policies are approved and a release manager deploys it; the faulty build is blocked); policy changes at runtime (revoking a policy denies the next action immediately, and changed policy code needs re-approval); tool and cost controls (capacity limits, data redaction, rate limits, per-run token cost); and multi-tenant isolation enforced in both the API and Postgres row-level security.Prototype notes: synthetic data and demo sign-in; it runs as one Docker container with a hosted Postgres database.

KeewanoPythonFastAPI+6

Align

K Squared

K-Squared: Align Align catches a junior engineer's mistaken assumptions before a commit or PR, and nudges them in the right direction while they work with Claude Code. Each prompt and each finished plan is checked automatically for the assumptions it rests on, and compared against a ground-truth knowledge base. That base contains only verified knowledge: decisions someone confirmed, and facts read from committed production code. The engineer is warned in three ways when they: - contradict that knowledge, - rebuild something that already exists, or - simply act on a material assumption that nothing confirms. A new feature usually has no ground truth yet, and the point is that they notice the assumption. The warnings appear: - Inside Claude Code. Claude is told the finding as hidden context and raises it as a question, citing the source. The engineer sees a short Align: line. A finished plan can be sent back for revision. - As a desktop pop-up (macOS, or Linux with notify-send). - At commit time, through an optional git pre-commit check. Nothing leaves the machine Align runs on. Findings show on the engineer's dashboard and, for whoever can open the same local server, on the team view. What counts as ground truth | Source | How it gets in | Verified by | |---|---|---| | Decision records (ADRs, requirements, conventions) | python3 -m align import . Only status: confirmed records; demoted ones are removed | the record's confirmed status | | Production code: classes and functions (Python, JS/TS), infrastructure (Terraform, CloudFormation), dependencies | python3 -m align knowledge scan --ref main | the git commit it was read from | | Facts a person checked by hand | python3 -m align knowledge add ... --verified-by " " | the named person | - Code scanning reads only committed code at the ref, never the working tree, so unmerged work can't become truth. Tests, vendored code and examples are skipped. - Re-scanning replaces a repo's code facts, so deleted code stops counting. - Every code fact keeps its verbatim source line as evidence. - The store refuses unverified facts. The knowledge base is a separate SQLite file (.align/knowledge.db, or ALIGN_KNOWLEDGE) behind the KnowledgeStore interface in align/knowledge/. That interface is the seam for moving it to a shared global service later. How assumptions are checked 1. Find related facts. For each prompt or plan, Align collects the task's decisions plus the production-code facts most related to the text (matched by shared word stems in names, paths and docstrings). 2. Name the assumptions. The first available detector is used: - Claude API (anthropic SDK plus ANTHROPIC_API_KEY). - Headless Claude Code (claude -p on your existing Claude Code login; no key needed). It runs with no tools, no settings or hooks, no MCP servers and no saved session, so it can't trigger Align recursively. It takes about 5–8 s with ALIGN_CLI_MODEL=sonnet. Either one names the assumptions behind the request, stated or not, as contradicted, already_exists or unconfirmed (at most two of those, and only material ones), quoting the engineer word for word. Offline rules are the fallback. They use each decision's forbid:/require: patterns, notice "create a new X" when production code already has an X, and flag work that depends on an external system ("the payments API") the knowledge base doesn't know. 3. Grounding check. An unconfirmed assumption needs an exact quote from the engineer and a commitment to act; there's no fact to cite. A conflict becomes a finding only if: - the fact exists, is verified and is current; - the fact quote appears word for word in the fact; - the engineer quote appears word for word in their message; - the engineer is committing rather than exploring. A model can't invent a finding past this check. 4. Severity: | Level | Meaning | Engineer sees | |---|---|---| | HIGH | Contradicts a confirmed decision | Claude raises it; alert dialog with Explore reason / Ask manager (placeholder); optional pause before file writes | | MEDIUM | Production code already has it, or works differently | Claude raises it; "check existing code first" banner | | LOW | A material assumption nothing verified confirms | Claude asks them to confirm it; "you might be operating on an assumption" banner | - A LOW finding counts as acknowledged when the engineer replies to Claude's question, or clicks I acknowledge this assumption on the dashboard. - A finding that was seen, acknowledged or dismissed isn't raised again in the same session. Only a resolved finding can recur. Quick start Requires Python 3.11+. The core has no dependencies. In another shell, replay scenarios through the real hook script and see what Claude and the engineer would be told: Use it with Claude Code Demo repo. examples/de-104/demo_repo/.claude/settings.json is already wired up (ALIGN_TASK_ID=DE-104, ALIGN_GATE=once). Open that folder in VS Code, run Claude Code there, check /hooks, and try "Write a new event schema validator for order events." Your own repository: - install-hooks merges into /.claude/settings.json and keeps your other hooks. - --git also installs the pre-commit check. It refuses to overwrite a pre-commit hook that isn't Align's unless you pass --force. - --git installs into the git repository that contains . For a subfolder of a larger repo, that's the larger repo. Team view shows a manager how the engineers assigned to a task are doing: - Headline numbers: engineers active, open assumptions, items waiting on the manager, rework hours at risk. - How Align checked the work: the pipeline from captured prompts through grounding to the engineer's answer, with a count at each step. The counts include claims the grounding check dropped. - Timeline: one lane per engineer. Shape shows what was sent (prompt, plan, tool call), color shows what Align found, and a dashed line joins each flagged assumption to the engineer's answer. Hover or focus a mark for details. - Waiting on your input: findings where the engineer chose "I have new evidence" or "Draft a question", with their note and draft. - One card per engineer: status (at risk, assumption flagged, needs your input, exploring, on track, aligned, not started), a progress stepper, their current direction, and each assumption with both quotes and their answer. Engineers are identified by ALIGN_ENGINEER (falling back to $USER) in the hook's environment, and listed in advance by the task's assignees. For a live demo, run scripts/demo.sh, open /manager, then in another shell: The team view shows engineers' prompts, assumptions and notes. Agree with your team on who can see it before using it outside a demo. How the engineer is nudged | Hook | What happens | |---|---| | UserPromptSubmit | Waits up to ALIGN_NUDGE_WAIT seconds (default 15) for analysis. New findings go to Claude as additionalContext and to the engineer as a systemMessage. | | PreToolUse on ExitPlanMode | The plan is analyzed. With the gate on, a plan with findings is denied, with the reason given to Claude so it revises the plan or asks the engineer. | | PreToolUse on Write/Edit/Bash | With ALIGN_GATE=once\|strict, an open HIGH finding makes Claude Code ask before the tool runs. | | PostToolUse | Findings that arrived after the prompt (slow analysis, tool-event findings) go to Claude here. | | git pre-commit | Lists open findings. It blocks only with ALIGN_GATE=strict and a HIGH finding open. | Each finding is delivered once. Everything fails open: if Align is down or slow, Claude and git carry on. Context format A task is a JSON file: {"id", "title", "goal", "assignees": ["name", ...], "work": [{"id", "description", "hours", "dependency", "invalidation"}]}. The work items feed the exposure estimate for HIGH findings. A record is Markdown with key: value frontmatter: Claude detection - Uses claude-opus-5-5 (ALIGN_MODEL) at low effort, with JSON-schema output and the server-side refusal fallback. - Prompts and plans use Claude. Tool events always use rules. - Any API error, timeout or refusal falls back to rules for that event. - Don't send employer content to an external API without permission. Settings | Variable | Default | Meaning | |---|---|---| | ALIGN_HOME | ./.align | Activity DB and token | | ALIGN_KNOWLEDGE | $ALIGN_HOME/knowledge.db | Ground-truth store; point several installs at one file to share it | | ALIGN_PORT | 8765 | Server port | | ALIGN_DETECTOR | auto | auto \| claude \| claude-code \| rules | | ALIGN_CLI_MODEL | sonnet | Model for the headless Claude Code detector | | ALIGN_MODEL | claude-opus-5-5 | Claude model for detection | | ALIGN_NOTIFY | auto | Desktop pop-ups: auto \| on \| off | | ALIGN_NUDGE_WAIT | 15 | Seconds the prompt/plan hook waits for analysis | | ALIGN_GATE | off | Hook-side: off, once (pause once per HIGH finding), strict (until responded; also blocks commits) | | ALIGN_TASK_ID | none | Hook-side: which task this repo works on | | ALIGN_ENGINEER | $USER | Hook-side: who is working, shown on the team view | | ALIGN_CAPTURE_COMMANDS | 0 | Hook-side: 1 captures Bash commands (redacted) as well as tool names | API All /api/ routes require X-Align-Token (the contents of .align/token). Requests whose Host isn't 127.0.0.1 or localhost are rejected. - GET /api/state?task=: tasks, records, knowledge stats, events, commitments, findings, work, exposure. - GET /api/team?task=: per-engineer status, direction, events and findings, plus pipeline counts, for the team view. - GET /api/hook?task=&session=&hook=prompt|plan|pre_tool|post_tool&mode=&event_id=: what that hook should say: decision, reason, system_message, additional_context. - GET /api/findings?task=&session=: open findings, most severe first. - GET /api/knowledge?q=&task=: search verified facts. - POST /api/events {task_id, session, engineer?, kind: prompt|plan|pre_tool|post_tool, content} → 202. - POST /api/respond {finding_id, response: use_existing|new_evidence|ask_manager|dismiss, note?}. ask_manager returns a question draft for the engineer to send themselves. - POST /api/import {path}. Development Limitations - Findings are scoped to a Claude Code session; a new session is re-checked from its own prompts and plans. - The rule detector's "already exists" check is word-stem matching on names, paths and docstrings. The Claude detector is much broader, but it's still bounded by the grounding check, by design. - Code facts cover top-level Python and JS/TS definitions, Terraform/CloudFormation resources, and Python/npm dependencies. - The exposure range is an illustrative estimate of rework at risk, not observed time saved. - Redaction is a regex pass. Get your organization's approval before using Align on real repositories.

DarwinAlike

AGI machinist

Instant Machinist turns a customer drawing into a verified CNC program in 7 minutes instead of 1–4 hours. Most of the 16,876 US machine shops are small, and every new part waits on a programmer. If each shop programs just one new part a day, that's 17,000–67,000 hours a day in the US alone, and many times that worldwide. Agent reads the drawing and programs the part in cloud Autodesk Fusion, and our simulator crash-checks every strategy before the fastest one is kept. On the NIST FTC-10 housing it saved 55–89 % of programming time, review included, and 76 % of machine time. Darwin sources what the shop is missing for the job, and Alike coordinated the 100+ agents that built it in a day.

DarwinAlikeAlike was crazy we ran 100 agents at the same time and got a complicated 3d simulator up and running with their help

MapAnything

Light Liu's team

Every intelligent product startup eventually hits the same bottleneck: the data that matters exists in different systems, with different schemas, different sampling rates, and different definitions of “normal.” Before the team can ship an agent, it has to label data, align records, and train custom models for each vertical. MapAnything turns that bottleneck into a reusable product layer. It maps two unfamiliar data worlds into an inspectable relationship, exposes evidence and confidence, and gives a startup a fast first path to a customer workflow. Fleet Agent makes the idea tangible: it connects vehicle telemetry to maintenance knowledge, explains an anomaly, and routes a truck to a targeted workshop.

JevGoogle Map APISaaS for startups

Pette

Pette is a desktop companion for developers to stay in the flow state. Instead of switching windows to send an email or a slack, you simply press a global hotkey and speak to Pette. It integrates directly with your IDE and screen context, "sees" what you see and reads the file you're actively working on to instantly draft and send messages without breaking your workflow.

DarwinElevenLabs