Platform

Hobie

Our agentic AI platform. Hobie builds governed agents for your data and for your software delivery, serves them in the tools your people already use, and learns from every answer and every merged pull request.

Architecture

One platform, five layers

Requests flow down through the layers. Answers and code flow back up, and Beacon learns from each one.

Shoreline

Where your people work

Agents are served over MCP, under your sign-in and access rules, in the tools your people already use: chat clients such as Claude Desktop, AI coding tools such as Claude Code, GitHub Copilot, Cursor, OpenAI Codex and Gemini, and browser apps for review and approval steps.

Shaper

Builds the agents

The Hobie Agent Framework, run by a Hang Ten forward-deployed engineer on your infrastructure. For your data, it reads your schemas, APIs and documents, models the business, then generates and tests the agents. For software delivery, it builds 23 agents from the Hobie seed and your answers to 66 intake questions. Either way, the result is one container of agents made for you.

Lens

The knowledge graph

What the agents know. For your data, a semantic layer of metrics, joins and vocabulary, where edits go live as overlays. For software delivery, the SDLC model and its rules, industry standards such as OWASP, NIST SSDF, SLSA and SBOM, your engineering graph of code, ADRs, tickets and PRs, and your domain knowledge.

Reef

Your systems, in place

Agents work in your systems, not copies of them: read-only scans and queries against your databases, business applications and documents, and your own source control, CI/CD, boards and security scanning, each behind a gate. Nothing is migrated.

Beacon

Learning and benchmarking

Spans every layer. Every answer and every merged pull request feeds a loop that tests the agents against your own work and proposes fixes, which ship only after a person approves them. The agents are benchmarked continuously, with fail-closed gates and every call logged.

How Hobie learns

What Hobie builds

Two kinds of agents, one platform

The same framework builds governed agents for your data and a full software delivery team. Both are served the same way, under the same controls, and improved by the same loop.

For your data

Governed agents, built from your systems

Hobie turns your databases, APIs and documents into tested agents, each served as typed MCP tools under your identity and access rules. SQL comes from a compiler that writes select-only queries or declines, and any write through an API needs confirmation.

  • Governed SQL
  • Governed RDF
  • API actions
  • Document search
  • Orchestrators
  • Pipelines and workflows
See it in practice

For software delivery

A 23-agent software delivery team

Generated for your stack and served to your engineers' AI coding tools, where they call each agent by @persona. Sixteen agents work in your repo, and seven work through your DevOps platforms. Independent reviewer agents check every change, and named people sign off.

  • Product owner
  • Architect
  • Backend
  • Frontend
  • Tester
  • Code reviewer
  • Security
  • Release manager
  • DORA analyst
How the delivery team works

Hobie for software delivery

A 23-agent software delivery team

In a 90-day engagement with a global wind-energy leader, Hang Ten delivered five applications 84% faster and at about a third lower cost than conventional development. Agents wrote all the code and documentation, independent reviewer agents checked every change, and named people signed off the plan, the review and the security.

84%

Faster per application: about 14 days, against about 90

~34%

Lower cost per application

93.1

Out of 100 on a delivery quality index, against about 75

>90%

Unit and functional test coverage, up from 65% and 50%

0

Critical or high security findings open at handover

Measured with the customer against its conventional development. Five applications were rebuilt from a legacy monolith, against three planned, with 2,849 automated tests run on every change. Cost covers delivery effort, the customer's review and acceptance time, and AI compute, and leaves out licences and infrastructure.

The agent team

Dev team · 16 agents

Work in your repo through your AI coding tools.

Discovery
  • Product owner
  • Business analyst
Delivery
  • Project manager
  • Orchestrator
Design
  • UX
  • Designer
Build
  • Architect
  • Backend
  • Frontend
  • Database
  • DevOps
Quality
  • Tester
  • Code reviewer
  • Security
Enablement
  • Docs
  • AI-ops

DevOps and process · 7 agents

Work through each platform's MCP server and API field map.

  • DORA analyst
  • Build analyst
  • Release manager
  • Issue triager
  • Error triager
  • Code review
  • Security

At the default autonomy level the agents draft and recommend, and your engineers carry out every write. You set the level in the intake, from reads only to acting on pre-approved patterns.

Beyond a single coding agent

A coding agent on its ownHobie SDLC agents, delivered with Hang Ten
Who checks the workThe same agent, or the developer who prompted itIndependent reviewer agents. The agent that writes the code can't approve or merge it
ControlsWhatever the developer asks it to runTests, security scans and reviews on every change, with nothing sampled
Before any codeA promptA backlog, design and threat model, each approved by a named person
What you getA pull requestCode, tests traced to requirements, release documentation and acceptance evidence
Where people spend timeReading large AI-written diffsSteering the agents, and verifying small changes after automatic checks
How you know it worksA demoA delivery quality index, and continuous benchmarks against a single coding agent

The gate in each area

The delivery agents work inside your engineering tools, and the Hobie seed sets a gate in each area.

AreaPlatformsGate in the Hobie seed
Source controlGitHub, GitLab, Azure DevOpsA merge needs an approval and green CI
CI/CDGitHub Actions, GitLab CI, Azure PipelinesNo production deploy on red CI
Boards and issuesGitHub Projects, Jira, Azure Boards, OpenProjectLabel changes and board moves need a person's approval
Security scanningGitHub code scanning, Dependabot, secret scanningNo deploy with an open critical finding
Releases and deploysTags, releases and deploymentsA person approves every release write
AI observabilityOpenTelemetry, Datadog, Grafana, SentryNo AI deploy without an eval gate

Your platforms' own settings, such as branch protection, enforce reviews and status checks. Product names are trademarks of their owners.

Built to be governed

Agents write the work. Named people stay accountable for it.

Verification is independent of generation

The agent that writes code has no route to approve or merge it. Reviewer agents run in the pipeline, and no one can approve or merge their own work.

Every control runs on every change

Tests, scans and reviews that used to be rationed by reviewer time run on every change. Nothing is sampled.

Sign-offs stay with people

A person accepts the backlog, approves the design and clears the threat model. Sign-offs at plan, review and security stay with named people.

Autonomy you choose

L0 reads only, L1 drafts and recommends (the default), L2 writes after a person approves, and L3 acts on pre-approved patterns and escalates exceptions.

Quality measured the same way for all

A delivery quality index scores build health, test quality, traceability, security and process hygiene, the same way for code written by agents or by people.

Your edits survive every rebuild

Your own section in each agent is kept byte for byte, and every generated agent carries a stamp with its version, generator, model and build time.

Beacon

Learning and benchmarking

Hobie Continuous Learning tests the agents against real use and improves them. Every answer and every merged pull request feeds the loop, a person approves each change before it ships, and benchmarks show whether it worked.

Data agents learn from every answer

  1. Step 1

    Log every answer

    Question, SQL or SPARQL, cost, latency and gaps, plus an audit log

  2. Step 2

    Capture feedback

    Corrections, confirmed answers and often-asked untested questions

  3. A person

    Human review

    A person promotes test cases and approves drafted fixes

  4. Step 4

    Benchmark

    Row check, LLM judge, and cost and latency budgets against a baseline

  5. Step 5

    Diagnose and fix

    Finds the failing layer, applies safe fixes and rolls back any regression

  6. Step 6

    Go live

    Overlays apply on the next query, and fixes merge into your Git

Delivery agents learn from every merged pull request

  1. Step 1

    Harvest findings

    AI and human reviews, CI failures and fix-up commits from merged PRs

  2. Step 2

    Find lessons

    Problems that recur across PRs, checked against the agents' rules

  3. Step 3

    Propose fixes

    Agent rules, knowledge entries, lint config or draft ADRs, each as a PR

  4. Step 4

    Verify

    Before-and-after runs on the evidence, with unchecked edits flagged

  5. A person

    A person merges

    Nothing reaches an agent until a person merges the PR

  6. Step 6

    Track each rule

    Rules that stop helping are proposed for rewording or retirement

Benchmarked continuously

Measured against the alternative

Hang Ten benchmarks the delivery agents continuously against a single coding agent on hidden tests, for accuracy, time and tokens. Data agents are tested against eval sets built from your own ground truth.

Gates and audit

Built into every step

Access is fail-closed and role-aware, through your identity provider. Every call is logged, and every answer and every change traces to the model, data and person behind it.

Why Hobie

What sets Hobie apart

Agents built for your systems and your stack, run under your controls, and improved on evidence from your own work.

Illustration: a governed record grants one person access and locks another out

Your data never moves

Agents query and work in your systems in place, with nothing copied or migrated.

Built for your stack

Agents are generated from your schemas, APIs, documents and intake answers, and tested before they ship.

Deterministic by design

Data agents emit structured intent that compiles to read-only queries, so answers stay safe and repeatable.

Learns from real use

Every answer and every merged pull request feeds a loop that tests and improves the agents, with a person approving each change.

Governed by default

Fail-closed, role-aware access with per-caller credentials, controls aligned to HIPAA, SOX and NIST, and every call logged.

You own what it builds

Agent packages, semantic models, eval sets and answer logs stay in your own Git and stores, with every approval in your tools.

A man in a striped shirt points to an engineering drawing on a screen during a meeting

In your program

Start with 90 days.

A Hang Ten team proves the method on a first set of your applications, with your experts steering and signing off. Results are measured against how you deliver today before you decide to scale. Our forward-deployed engineers generate the agents, set up the container that serves them, and teach your team to run and extend them.

Talk to us

Start with your biggest program.

Tell us about the software or transformation you want to accelerate.

Discuss your program