Expert Data Analysis For Anyone

Add data. Ask questions. Reveal insights — without engineers.

What We’re Building
JUXX22 is an autocoder that uses plain English to build complete data pipelines. AI agents plan, test, and construct Lego-like components that create a visual blueprint, making complex workflows intuitive. Each component is validated in isolation with synthetic data making it easy for non-technical users to customize, build upon, and explore new directions.While compatible with nearly any dataset, we intend to be the first to effectively populate your data into dynamic knowledge graphs. These graphs serve as an enhanced memory layer for reasoning and context reuse between your queries, which creates a self-improving loop in which each analysis adapts as your insights evolve.Easily analyze, quickly iterate, and discover tailored insights at scale.


How It Works

  1. Enter your query in natural language.

  2. JUXX22 analyzes the problem and goal, then disassembles it into the raw elements needed to engineer a complete data pipeline solution.

  3. AI assembles these elements into modular components with specialized roles and responsibilities tailored to your goal.

  4. JUXX22 then constructs a solutions blueprint, defining how the components communicate via strictly typed input/output ports to ensure data integrity, adaptability, and scalability.

  5. JUXX22 then writes code for each component individually, optimizing the process and supporting complex workflows and diverse data sources.

  6. Each component is tested in isolation using AI-generated sample data, to ensure alignment with your goal.

  7. Errors are automatically detected and corrected at the component level, preventing cascades typical of monolithic systems.

  8. Validated components are configured into a cohesive and adaptive system.

  9. JUXX22 conducts comprehensive end-to-end testing, ensuring all components work together seamlessly; if not, it continues troubleshooting until they do.

  10. Data is populated into knowledge graphs to add an enhanced memory layer for reasoning, learning, and context reuse.

  11. JUXX22 then delivers an intuitive visual map offering full transparency into how each part functions and fits together. Including plug-and-play components that can be swapped between queries for easily customized configurations.

  12. Build, iterate, and scale data pipelines with a flexible architecture that self-improves as your insights are fed back into the knowledge graph.


Why JUXX22 Scales
Memory vs. Computation separation – The knowledge graph can grow organically, while the autocoder pipelines stay lean and task‑specific.LLM feasibility – Each step is small enough to fit into an LLM context window for code‑gen/debug.Evolvability – You can swap storage back‑ends, add new operator libraries, support MCP, or point the autocoder at a different dataset without rewiring everything.


How JUXX22 Handles Any Data Pipeline Challenge.
JUXX22 decomposes complex data flows into four modular, testable, type-safe components—avoiding the fragility of monolithic systems and enabling precise, adaptable pipelines.1. DataObject - The Structured Carriers
Hold typed data at various stages of processing, ensuring consistent input/output contracts.Example: RawDocument, ProcessedText2. Processor - The Transformers
Transforms one DataObject into another.Example: TextExtractor converts RawDocument into ProcessedText3. Router - The Intelligent Directors
Analyze DataObjects and route them to the correct downstream processors based on content or format.Example: FormatRouter sends content to either HTMLProcessor or MarkdownProcessor4. Reducer - The Result Aggregators
Merge multiple processed outputs into a unified result for downstream use.
Example: FormatCollector merges formatted outputs into a single ProcessedText DataObject


Type-Safe Communication Through Ports and Schemas
All components communicate through strictly typed input and output ports, preserving structure and validation throughout the pipeline.Runtime validation is enforced via Pyadantic schemas attached to each DataObject.Both Routers and Reducers are composable, meaning they can be nested to support more complex or recursive workflows without breaking modularity.


Advanced Workflow With Routers and Reducers
Router and Reducer components enable complex conditional paths and result aggregation, unlocking sophisticated flows without breaking modularity.

-Router (FormatRouter) splits flow between HTML/Markdown processors.
-Reducer (FormatCollector) merges their outputs.


Iterative Development With Focused Testing
Each component is tested independently using LLM-generated test data. This modularity allows:
-Rapid debugging
-Focused validation
-Multiple feedback loops for system improvement


What Differentiates Us

  • Goal-driven pipeline generation – Converts natural-language objectives into complete, testable Python pipelines built step-by-step.

  • Modular, schema-defined architecture – Workflows are composed of isolated, typed components with ports, routers, and loops.

  • LLM-compatible design – Each step fits within a language model’s context window for reliable code generation and debugging.

  • Agent-native infrastructure – Enables autonomous agents to plan, coordinate, and execute structured, auditable workflows.

  • Integrated knowledge graphs – Acts as a long-term memory layer for reasoning, context reuse, and knowledge retention.

  • Self-improving loop – Insights are written back into the graph, allowing workflows to improve with each run.

  • Visual transparency – All processes are visualized as directed graphs for easy inspection, editing, and version control.

  • Composable and flexible – Processes, data sources, MCP interfaces, and process steps can be swapped without breaking the system.

  • Unifies reasoning and execution – Combines structured memory, dynamic planning, and tested execution in a single system.

  • Blueprint-driven control layer – All logic and connections originate from a centralized declarative blueprint, making workflows easy to inspect and modify.

  • Clear roles, clean boundaries – State, logic, routing, and aggregation are separated into distinct components, making behavior predictable and reducing complexity.

  • Isolated side effects – State changes and external interactions are contained within specific modules, promoting clarity and trust.

  • Machine-readable architecture – The entire system is structured for easy parsing and understanding by both AI agents and human developers.

  • Tests in isolation – Every component is validated independently to ensure reliability, simplify debugging, and enable reuse.



Explanation Of Our Vision



Abstract Thinking: The Art Of Pruning And Knowledge Graphs (Scale-Free)



Demo Video Of The Autocoder On A Calculator


We are looking to hire someone to help build the autocoder.While we have been coding this ourselves, progress has been 2 steps forward 1 step back, and we are looking to speed it up.Ideally, besides relevant Python experience, you have some understanding of the potential and purpose of such a system.Autocoder MVP Project: Goal & RequirementsA critical part of this platform is the Autocoder System – the component you’d be primarily working on initially. It uses a modular, visual, diagram-driven approach where:
Systems are broken down into smaller components with defined interfaces (input/output ports with specific data schemas).These components are represented in diagrams that specify the system's structure and data flow.
The Autocoder utilizes LLMs to help generate these diagrams and the code for each component, allowing them to be tested in isolation before integration based on the diagram.
This modular approach helps manage complexity and work effectively with LLMs in the context of larger codebases.Goal: Develop an MVP of the Autocoder framework.Success = The Autocoder's ability to reliably generate functional, reasonably compliant Python systems that solve the 4 benchmark problems.Current Status: We are currently building and stabilizing the core autocoder system (~10,000+ lines of Python code). Its reliability is important for the larger project.Details:
-The role involves verifying LLM-generated code, and implementing manual corrections across files/modules, and identifying root causes.-Familiarity with prompt engineering is great, but we need code-level verification/correction over solely focusing on prompt engineering.-The documentation (implementationdocs/, especially designconsiderations.txt, autocodersystemguide.txt, implementationguide.md) provides guidance on the architecture and planned features. You’ll use this as a guide for functional alignment.-Minor structural deviations are fine, but let’s discuss major ones.-Ability to diagnose problems, trace issues across files/modules, and identify root causes in complex code.MVP Success Criteria:
The Autocoder MVP should “solve” the 4 benchmark problems listed below.
"Solving" = meeting the below criteria for each benchmark:1. Input: Processes the Natural Language description without errors.
2. Generation: Generates all required system artifacts (analysis.json, component code, configuration.json, main.py, etc.).
3. Execution: Runs correctly via main.py using input.json test data.
4. Correctness: Produces the correct final output.json.
5. Reasonable Architectural Compliance: Artifacts follow core principles (e.g., component types, decomposition, naming, data handling).
6. General Purpose Framework: The Autocoder framework itself remains general-purpose, NOT hardcoded only to these examples.Benchmark Problems to Solve:
1. Eligibility Check
Goal: Determine if a user qualifies for an offer based on age and country.
Process:
a. Start with user details (e.g., name 'Bob', age 25, country 'US').
b. Apply the rule: qualify if age more than 18 AND country == 'US'.
c. Based on the result, create a status message (e.g., "User Bob is eligible." or "User Bob is ineligible.").
d. Save the final status message.2. Stock Tracking
Goal: Track and update the stock level for a product.
Process:
a. Initialize stock for 'productA' at 10 units.
b. Process two separate incoming shipment updates: one adds 5 units, another adds 3 units.
c. Calculate the total final stock level after both updates.
d. Store this final calculated stock level and make it available for viewing.3. Profile Update
Goal: Manage and update a basic user profile.
Process:
a. Begin with stored user data (e.g., name 'Charlie', email '[email address removed]').
b. Process an incoming update to change the email (e.g., to '[email address removed]'), modifying the stored profile.
c. After the update, retrieve the complete, current profile data (name and new email).
d. Save this retrieved profile as a final snapshot.4. Simple Order Processing
Goal: Process order items, calculate subtotal, apply conditional discount, determine final total.
Process:
a. Start with order details - Customer ID "CUST-007"
b.list of items ordered:
-Apple, qty 2, price 1.50
-Banana, qty 0, price 0.75
-Orange, qty 3, price 2.00
c. Calculate line total (qty * price) for each item only if quantity greater than 0.
d. Sum valid line totals to get the order subtotal.
d. Check if the subtotal is $5.00 or more; if yes, calculate a 10% discount amount; otherwise the discount is $0.
e. Calculate the final total price (subtotal - discount amount).
f. Store and make available a result including customer ID, final total price, the calculated discount amount, and a list of the IDs of items actually processed (had qty greater than 0).
g.Make the final result available for lookup.Finally, please send
1. Relevant links to your work to [email protected]
2. A brief message on why you're a fit. Sorry, but I'm not even going to read AI-generated responses. I'm not asking for much.
3. I'll reach out to you to do hopefully 1 interview, and decide after that.Thank you for your time.