Walker AI

Type an idea. Get a prototype. In 30 seconds powered by Multiple AI agents built on Jac.

Comment

What Inspired Us

Every hackathon starts the same way — someone throws out a rough idea, and the next 2 hours are wasted arguing about tech stack, writing PRDs nobody reads, and debating folder structures.

We asked one question: what if an AI team could do all of that in under a minute?

That's SpawnAI. Not a chatbot. Not a wrapper. A real multi-agent pipeline built entirely on Jac — where 4 specialized AI agents collaborate in sequence to turn one raw sentence into a complete, downloadable prototype.

How We Built It

We used Jac (jaclang) as the core runtime — the world's first agentic-native programming language. The architecture is a clean sequential pipeline:

Raw Idea → Scout → Planner → Architect → Code Agent → Prototype

Each agent is a Jac function annotated with by llm(). Jac handles prompt construction, LLM calls, and structured JSON parsing automatically. No LangChain. No LangGraph. Pure Jac.

Agent Role Output
Scout Idea refiner PRD JSON
Planner Product manager Milestones + tagline
Architect System designer Tech stack + folder structure
Code Agent Full-stack dev 7 starter files, ready to run

The orchestrator is a single Jac walker that traverses an IdeaNode on a PrototypeGraph, calling each agent in sequence:

walker build_idea_to_prototype {
    has raw_input: str;
    can run with IdeaNode entry {
        here.prd          = refine_idea(here.raw_idea);
        here.planned      = generate_plan(here.prd);
        here.architecture = design_architecture(here.planned);
        here.starter_code = generate_starter_code(here.architecture, here.prd);
        report { "files": here.starter_code };
    }
}

The pipeline follows a strict sequential dependency model where each agent's output becomes the next agent's input:

\( \text{Output}n = f_n(\text{Output}{n-1}), \quad n \in {1, 2, 3, 4} \)

Where each \( f_n \) is a by llm() Jac function with a specialized system prompt and typed return schema.

The total information gain across the pipeline can be expressed as:

$$ I_{total} = \sum_{n=1}^{4} I(f_n) $$

Where \( I(f_n) \) is the structured information produced by agent \( n \) — starting from an unstructured idea and ending in runnable code.

What We Learned

  1. Jac's by llm() eliminates agent boilerplate entirely. The function docstring becomes the system prompt. The return type becomes the output schema. Jac enforces it automatically.

  2. Walkers are the right mental model for multi-agent systems. Instead of orchestration frameworks, walkers give you a spatial metaphor: agents move through a graph, pick up state, and hand off to the next node.

  3. Sequential agents beat parallel ones for hackathon demos. Judges can follow the chain in real time — each step visibly builds on the last.

  4. Prompt engineering is harder than architecture. Getting each agent to return clean, consistent JSON that the next agent consumes without errors took more iterations than the entire Jac codebase.

Challenges We Faced

1. Jac to Python Bridge FastAPI needed to invoke the Jac walker and receive its report output. We solved this by running Jac as a subprocess from Python and parsing stdout as JSON — simple, reliable, and demo-safe.

2. Chained Agent State Consistency If Agent 2 returns a slightly different key than Agent 3 expects, the pipeline breaks silently. We fixed this by enforcing strict output schemas in every by llm() docstring: "Return only valid JSON with keys: X, Y, Z."

3. Latency 4 sequential LLM calls average 15–25 seconds end-to-end. We masked this with a step-by-step loading UI that shows which agent is running in real time — so it feels instant even when it isn't.

4. Time We built SpawnAI in under 4 hours at JacHacks 2026.

What's Next

  • Parallel agent execution for independent subtasks
  • GitHub auto-push — create a repo and push starter code directly
  • Voice input — speak your idea, get a prototype
  • Memory across sessions using Jac graph persistence

Built at JacHacks 2026 with Jac, jaclang, FastAPI, OpenAI GPT-4o, and a lot of determination.

Built With

Share this project:

Updates